/// <summary>
/// Gets the internal stress at defined location.
/// tensor is in local coordinate system.
/// </summary>
/// <param name="isoLocation">The location for the stress probe in iso coordinates. Order: x,y,z. Maximum bending stress at the shell thickness (z=1.0). Must be withing 0 and 1.</param>
/// <param name="combination">The load combination.</param>
/// <param name="probeLocation">The probe location for the stress.</param>
/// <returns>Stress tensor of flat shell, in local coordination system</returns>
/// <remarks>
/// for more info about local coordinate of flat shell see page [72 of 166] (page 81 of pdf) of "Development of Membrane, Plate and Flat Shell Elements in Java" thesis by Kaushalkumar Kansara freely available on the web
/// </remarks>
public FlatShellStressTensor GetInternalStress(double[] isoLocation, LoadCombination combination, SectionPoints probeLocation)
{
if (isoLocation[2] < 0 || isoLocation[2] > 1.0)
{
throw new Exception("z must be between 0 and 1. 0 is the centre of the plate and 1 is on the plate surface. Use the section points to get the top/bottom.")
{
};
}
var helpers = GetHelpers();
var buf = new FlatShellStressTensor();
for (var i = 0; i < helpers.Count(); i++)
{
if (helpers[i] is Q4MembraneHelper)
{
buf.MembraneTensor = ((Q4MembraneHelper)helpers[i]).GetLocalInternalStress(this, combination, isoLocation).MembraneTensor;
}
else if (helpers[i] is DkqHelper)
{
buf.BendingTensor = ((DkqHelper)helpers[i]).GetBendingInternalStress(this, combination, isoLocation).BendingTensor;
}
}
buf.UpdateTotalStress(_section.GetThicknessAt(new double[] { isoLocation[0], isoLocation[1] }) * isoLocation[2], probeLocation);
return(buf);
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private IFBasicCombination CreateLoadCombination(LoadCombination loadCombination)
{
IFBasicCombination lusasLoadcombination;
List <double> loadFactors = new List <double>();
List <int> loadcases = new List <int>();
if (d_LusasData.existsLoadset(loadCombination.Name))
{
lusasLoadcombination = (IFBasicCombination)d_LusasData.getLoadset(loadCombination.Name);
}
else
{
if (loadCombination.Number == 0)
{
lusasLoadcombination = d_LusasData.createCombinationBasic(loadCombination.Name);
Compute.RecordWarning($"LoadCombination {loadCombination.Name} ID will be autogenerated by Lusas.");
}
else
{
lusasLoadcombination = d_LusasData.createCombinationBasic(loadCombination.Name, "", loadCombination.Number);
}
foreach (Tuple <double, ICase> factoredLoad in loadCombination.LoadCases)
{
double factor = factoredLoad.Item1;
IFLoadset lusasLoadcase = d_LusasData.getLoadset(factoredLoad.Item2.AdapterId <int>(typeof(LusasId)));
lusasLoadcombination.addEntry(factor, lusasLoadcase);
}
}
return(lusasLoadcombination);
}
/// <summary>
/// Sets the named sets database tables 2 selections.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="table">The table.</param>
private static void setNAMED_SETS_DATABASE_TABLES_2_SELECTIONS(Model model, List <Dictionary <string, string> > table)
{
foreach (Dictionary <string, string> tableRow in table)
{
TableSet tableSet = model.OutputSettings.FillItem(tableRow["DBNamedSet"]);
switch (tableRow["SelectType"])
{
case "Table":
tableSet.TableNames.Add(tableRow["Selection"]);
break;
case "LoadPattern":
LoadPattern loadPattern = model.Loading.Patterns.FillItem(tableRow["Selection"]);
tableSet.LoadPatterns.Add(loadPattern);
break;
case "LoadCase":
LoadCase loadCase = model.Loading.Cases.FillItem(tableRow["Selection"]);
tableSet.LoadCases.Add(loadCase);
break;
case "Combo":
LoadCombination loadCombo = model.Loading.Combinations.FillItem(tableRow["Selection"]);
tableSet.LoadCombinations.Add(loadCombo);
break;
}
}
}
protected override void SolveInstance(IGH_DataAccess DA)
{
// get data
string name = null, type = "ultimate_ordinary";
List <LoadCase> loadCases = new List <LoadCase>();
List <double> gammas = new List <double>();
if (!DA.GetData(0, ref name))
{
return;
}
if (!DA.GetData(1, ref type))
{
// pass
}
if (!DA.GetDataList(2, loadCases))
{
return;
}
if (!DA.GetDataList(3, gammas))
{
return;
}
if (name == null || type == null || loadCases == null || gammas == null)
{
return;
}
var _type = FemDesign.GenericClasses.EnumParser.Parse <LoadCombType>(type);
LoadCombination obj = new LoadCombination(name, _type, loadCases, gammas);
DA.SetData(0, obj);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static LoadCombination ToLoadCombination(
this IFBasicCombination lusasLoadCombination,
Dictionary <string, Loadcase> loadcases)
{
object[] loadcaseIDs = lusasLoadCombination.getLoadcaseIDs();
object[] loadcaseFactors = lusasLoadCombination.getFactors();
List <Tuple <double, ICase> > factoredLoadcases = new List <Tuple <double, ICase> >();
Loadcase loadcase = null;
for (int i = 0; i < loadcaseIDs.Count(); i++)
{
int loadcaseID = (int)loadcaseIDs[i];
double loadcaseFactor = (double)loadcaseFactors[i];
loadcases.TryGetValue(loadcaseID.ToString(), out loadcase);
Tuple <double, ICase> factoredLoadcase = new Tuple <double, ICase>(loadcaseFactor, loadcase);
factoredLoadcases.Add(factoredLoadcase);
}
LoadCombination loadCombination = new LoadCombination
{
Name = GetName(lusasLoadCombination),
Number = lusasLoadCombination.getID(),
LoadCases = factoredLoadcases
};
int adapterNameId = lusasLoadCombination.getID();
loadCombination.SetAdapterId(typeof(LusasId), adapterNameId);
return(loadCombination);
}
public static void SetLoadCombination(cSapModel model, LoadCombination loadCombination)
{
//string combinationName = loadCombination.CustomData[AdapterId].ToString();
string combinationName = CaseNameToCSI(loadCombination);
model.RespCombo.Add(combinationName, 0);//0=case, 1=combo
foreach (var factorCase in loadCombination.LoadCases)
{
double factor = factorCase.Item1;
Type lcType = factorCase.Item2.GetType();
string lcName = CaseNameToCSI(factorCase.Item2);// factorCase.Item2.Name;// Number.ToString();
eCNameType cTypeName = eCNameType.LoadCase;
if (lcType == typeof(Loadcase))
{
cTypeName = eCNameType.LoadCase;
}
else if (lcType == typeof(LoadCombination))
{
cTypeName = eCNameType.LoadCombo;
}
model.RespCombo.SetCaseList(combinationName, ref cTypeName, lcName, factor);
}
}
public static LoadCombination GetLoadCombination(cSapModel model, Dictionary <string, ICase> caseDict, string id)
{
LoadCombination combination = new LoadCombination();
int number;
string[] nameNum = id.Split(new[] { ":::" }, StringSplitOptions.None);
int.TryParse(nameNum[1], out number);
combination.Number = number;
combination.Name = nameNum[0];
string[] caseNames = null;
double[] factors = null;
int caseNum = 0;
eCNameType[] nameTypes = null;//<--TODO: maybe need to check if 1? (1=loadcombo)
model.RespCombo.GetCaseList(id, ref caseNum, ref nameTypes, ref caseNames, ref factors);
if (caseNames != null)
{
ICase currentCase;
for (int i = 0; i < caseNames.Count(); i++)
{
if (caseDict.TryGetValue(caseNames[i], out currentCase))
{
combination.LoadCases.Add(new Tuple <double, ICase>(factors[i], currentCase));
}
}
}
return(combination);
}
/***************************************************/
/**** Private methods ****/
/***************************************************/
private bool CreateObject(LoadCombination bhLoadCombo)
{
int err;
int uID = 1;
int loadCaseType = St7.ltLoadCase;
int freedomCaseNum = 1;
int loadComboId = GetAdapterId <int>(bhLoadCombo);
List <Loadcase> allLoadCases = ReadLoadcase();
var comparer = new BHoMObjectNameOrToStringComparer();
err = St7.St7AddLSACombination(uID, bhLoadCombo.Name);
if (err != St7.ERR7_NoError)
{
err = St7.St7SetLSACombinationName(uID, loadComboId, bhLoadCombo.Name);
if (!St7ErrorCustom(err, "Could not create or update a load combination number " + loadComboId))
{
return(false);
}
}
foreach (Tuple <double, ICase> tuple in bhLoadCombo.LoadCases)
{
Loadcase ldcas = allLoadCases.Where(x => x.Number == (tuple.Item2 as Loadcase).Number).FirstOrDefault();
int lCaseNum = ldcas.Number;
// int lCaseNum = GetAdapterId<int>(ldcas);
err = St7.St7SetLSACombinationFactor(uID, loadCaseType, loadComboId, lCaseNum, freedomCaseNum, tuple.Item1);
if (!St7ErrorCustom(err, "Could not set load case " + lCaseNum + " factor for a load combo " + loadComboId))
{
return(false);
}
}
return(true);
}
/***************************************************/
public static LoadCombination ToBHoMObject(IModel ramModel, ILoadCombination ramLoadCombination)
{
LoadCombination loadCombination = new LoadCombination();
loadCombination.Name = ramLoadCombination.strDisplayString;
loadCombination.Number = ramLoadCombination.lLabelNo;
ILoadCombinationTerms iLoadCombinationTerms = ramLoadCombination.GetLoadCombinationTerms();
for (int i = 0; i < iLoadCombinationTerms.GetCount(); i++)
{
//Get LoadCombination Cases and Factors
ILoadCombinationTerm iLoadCombinationTerm = iLoadCombinationTerms.GetAt(i);
int caseID = iLoadCombinationTerm.lLoadCaseID;
ILoadCases iLoadCases = ramModel.GetLoadCases(EAnalysisResultType.RAMFrameResultType);
ILoadCase iLoadCase = iLoadCases.Get(caseID);
//Convert Loadcase from RAM to BHoM
Loadcase bhomLoadcase = ToBHoMObject(iLoadCase);
//Add dict for load factor and loadcase
loadCombination.LoadCases.Add(new Tuple <double, ICase>(iLoadCombinationTerm.dFactor, bhomLoadcase));
}
return(loadCombination);
}
String m_usage; // Indicate usage column of LoadCombination DataGridView control
#endregion Fields
#region Constructors
/// <summary>
/// Default constructor of LoadCombinationMap
/// </summary>
/// <param name="combination">the reference of LoadCombination</param>
public LoadCombinationMap(LoadCombination combination)
{
m_name = combination.Name;
m_type = combination.CombinationType;
m_state = combination.CombinationState;
// Generate the formula property.
StringBuilder formulaString = new StringBuilder();
for (int i = 0; i < combination.NumberOfComponents; i++)
{
formulaString.Append(combination.get_Factor(i));
formulaString.Append("*");
formulaString.Append(combination.get_CombinationCaseName(i));
// Add plus sign between each case.
if (i < combination.NumberOfComponents - 1)
{
formulaString.Append(" + ");
}
}
m_formula = formulaString.ToString();
// Generate the usage property.
StringBuilder usageString = new StringBuilder();
for (int i = 0; i < combination.NumberOfUsages; i++)
{
usageString.Append(combination.get_UsageName(i));
// Add semicolon between each usage.
if (i < combination.NumberOfUsages - 1)
{
usageString.Append(";");
}
}
m_usage = usageString.ToString();
}
/***************************************************/
private bool CreateObject(LoadCombination loadCombination)
{
if (m_model.RespCombo.Add(loadCombination.Name, 0) == 0) //0=case, 1=combo
{
foreach (var factorCase in loadCombination.LoadCases)
{
double factor = factorCase.Item1;
Type lcType = factorCase.Item2.GetType();
string lcName = factorCase.Item2.Name;// factorCase.Item2.Name;// Number.ToString();
eCNameType cTypeName = eCNameType.LoadCase;
if (lcType == typeof(Loadcase))
{
cTypeName = eCNameType.LoadCase;
}
else if (lcType == typeof(LoadCombination))
{
cTypeName = eCNameType.LoadCombo;
}
m_model.RespCombo.SetCaseList(loadCombination.Name, ref cTypeName, lcName, factor);
}
SetAdapterId(loadCombination, loadCombination.Name);
}
else
{
CreateElementError(loadCombination.GetType().ToString(), loadCombination.Name);
}
return(true);
}
public LoadCombinationsDialog(Canguro.Model.Model model, LoadCombination combo)
{
this.currentCombo = combo;
this.model = model;
InitializeComponent();
wizardControl.HideTabs = true;
oneCombo = (combo != null);
}
/***************************************************/
private bool CreateObject(LoadCombination loadcombination)
{
bool success = true;
Helper.SetLoadCombination(m_model, loadcombination);
return(success);
}
public Displacement GetInternalDisplacementAt(double xi, LoadCombination combination)
{
var buf = new Displacement();
foreach (var pair in combination)
{
buf += pair.Value * GetInternalDisplacementAt(xi, pair.Key);
}
return(buf);
}
/// <summary>
/// Gets the exact internal force at <see cref="xi" /> position.
/// </summary>
/// <param name="xi">The iso coordinate of desired point (start = -1, mid = 0, end = 1).</param>
/// <param name="combination">The Load Combination.</param>
/// <returns></returns>
/// <remarks>
/// Will calculate the internal forces of member regarding the <see cref="combination" />
/// </remarks>
public Force GetExactInternalForceAt(double xi, LoadCombination combination)
{
var buf = Force.Zero;
foreach (var lc in combination.Keys)
{
buf += combination[lc] * this.GetExactInternalForceAt(xi, lc);
}
return(buf);
}
private void backButton_Click(object sender, EventArgs e)
{
if (oneCombo)
{
DialogResult = DialogResult.Cancel;
}
else
{
currentCombo = null;
wizardControl.SelectTab(0);
}
}
private void editComboLinkLabel_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
LoadCombination combo = (allCombosListBox.SelectedItem != null) ? (LoadCombination)allCombosListBox.SelectedItem :
(selectedCombosListBox.SelectedItem != null) ? (LoadCombination)selectedCombosListBox.SelectedItem : null;
if (combo != null)
{
Canguro.Commands.Forms.LoadCombinationsDialog dlg = new Canguro.Commands.Forms.LoadCombinationsDialog(services.Model, combo);
dlg.ShowDialog(this);
updateDesignCombosPage();
}
}
private void store(OleDbConnection cn, LoadCombination obj, Canguro.Model.Model model)
{
List <AbstractCaseFactor> list = obj.Cases;
string sql = "";
string steel = CodeYN(model.SteelDesignOptions.DesignCombinations.Contains(obj));
string concrete = CodeYN(model.ConcreteDesignOptions.DesignCombinations.Contains(obj));
string alum = CodeYN(model.AluminumDesignOptions.DesignCombinations.Contains(obj));
string cold = CodeYN(model.ColdFormedDesignOptions.DesignCombinations.Contains(obj));
string comboType = GetComboType(obj.Type);
foreach (AbstractCaseFactor f in list)
{
AbstractCase aCase = f.Case as AbstractCase;
sql = "";
if (aCase != null) // && aCase.IsActive)
{
if (aCase is LoadCombination)
{
sql = "INSERT INTO [Combination Definitions] " +
"(ComboName,ComboType,CaseType,CaseName,ScaleFactor,SteelDesign,ConcDesign,AlumDesign,ColdDesign) VALUES " +
"(\"" + obj.Name + "\",\"\",\"Combo\",\"" + aCase.Name + "\"," + f.Factor + "," + steel + "," + concrete + "," + alum + "," + cold + ");";
}
else if (aCase is AnalysisCase)
{
AnalysisCaseProps props = ((AnalysisCase)aCase).Properties;
if (props is StaticCaseProps)
{
// StaticCaseProps sprops = (StaticCaseProps)props;
sql = "INSERT INTO [Combination Definitions] " +
"(ComboName,ComboType,CaseType,CaseName,ScaleFactor,SteelDesign,ConcDesign,AlumDesign,ColdDesign) VALUES " +
"(\"" + obj.Name + "\",\"" + comboType + "\",\"Linear Static\",\"" + aCase.Name + "\"," + f.Factor + "," + steel + "," + concrete + "," + alum + "," + cold + ");";
}
else if (props is ResponseSpectrumCaseProps)
{
sql = "INSERT INTO [Combination Definitions] " +
"(ComboName,ComboType,CaseType,CaseName,ScaleFactor,SteelDesign,ConcDesign,AlumDesign,ColdDesign) VALUES " +
"(\"" + obj.Name + "\",\"" + comboType + "\",\"Response Spectrum\",\"" + aCase.Name + "\"," + f.Factor + "," + steel + "," + concrete + "," + alum + "," + cold + ");";
}
//steel = concrete = alum = cold = "\"\"";
}
if (sql.Length > 0)
{
new OleDbCommand(sql, cn).ExecuteNonQuery();
}
}
}
// Insert record in RESULTS Named Set
sql = " INSERT INTO [Named Sets - Database Tables 2 - Selections] " +
"(DBNamedSet, SelectType, [Selection]) VALUES (\"RESULTS\", \"Combo\", \"" + obj.Name + "\");";
new OleDbCommand(sql, cn).ExecuteNonQuery();
}
/// <summary>
/// Sets a load combination selected for output flag.
/// </summary>
/// <param name="loadCombination">An existing load combination.</param>
public void SetComboSelectedForOutput(LoadCombination loadCombination)
{
if (loadCombination.IsSelectedForAnalysis)
{
if (!CombosSelectedForOutput.Contains(loadCombination))
{
CombosSelectedForOutput.Add(loadCombination);
}
}
else
{
CombosSelectedForOutput.Remove(loadCombination);
}
}
public RFLoadCombo(LoadCombination load)
{
Comment = load.Comment;
ID = load.ID;
IsValid = load.IsValid;
No = load.Loading.No;
Tag = load.Tag;
ToSolve = load.ToSolve;
Description = load.Description;
Definition = load.Definition;
DesignSituation = load.DesignSituation;
ToModify = false;
ToDelete = false;
}
/// <summary>
/// Gets the internal force at defined location.
/// tensor is in local coordinate system.
/// </summary>
/// <param name="localX">The X in local coordinate system (see remarks).</param>
/// <param name="localY">The Y in local coordinate system (see remarks).</param>
/// <param name="combination">The load combination.</param>
/// <returns>Stress tensor of flat shell, in local coordination system</returns>
/// <remarks>
/// for more info about local coordinate of flat shell see page [72 of 166] (page 81 of pdf) of "Development of Membrane, Plate and Flat Shell Elements in Java" thesis by Kaushalkumar Kansara freely available on the web
/// </remarks>
public FlatShellStressTensor GetInternalForce(double localX, double localY, LoadCombination combination)
{
var buf = new FlatShellStressTensor();
if ((this._behaviour & FlatShellBehaviour.ThinPlate) != 0)
{
buf.MembraneTensor = GetMembraneInternalForce(combination);
}
if ((this._behaviour & FlatShellBehaviour.Membrane) != 0)
{
buf.BendingTensor = GetBendingInternalForce(localX, localY, combination);
}
return(buf);
}
/// <summary>
/// Builds an adjacencyList of dependant abstract cases, so that each entry has its dependant cases in its list
/// </summary>
/// <returns>The adjacency list</returns>
public Dictionary <AbstractCase, LinkedList <AbstractCase> > BuildAnalysisCaseAdjacency()
{
Dictionary <AbstractCase, LinkedList <AbstractCase> > adjancencyList = new Dictionary <AbstractCase, LinkedList <AbstractCase> >();
AnalysisCase aCase = null;
LoadCombination combo = null;
foreach (AbstractCase ac in abstractCases)
{
if ((aCase = ac as AnalysisCase) != null)
{
if (aCase.Properties.DependsOn == null)
{
if (!adjancencyList.ContainsKey(aCase))
{
adjancencyList.Add(aCase, new LinkedList <AbstractCase>());
}
}
else if (adjancencyList.ContainsKey(aCase.Properties.DependsOn))
{
adjancencyList[aCase.Properties.DependsOn].AddLast(aCase);
}
else
{
adjancencyList.Add(aCase.Properties.DependsOn, new LinkedList <AbstractCase>());
adjancencyList[aCase.Properties.DependsOn].AddLast(aCase);
}
}
else if ((combo = ac as LoadCombination) != null)
{
foreach (AbstractCaseFactor acf in combo.Cases)
{
if (adjancencyList.ContainsKey(acf.Case))
{
adjancencyList[acf.Case].AddLast(combo);
}
else
{
adjancencyList.Add(acf.Case, new LinkedList <AbstractCase>());
adjancencyList[acf.Case].AddLast(combo);
}
}
}
}
return(adjancencyList);
}
/***************************************************/
private List <LoadCombination> ReadLoadCombination(List <string> ids = null)
{
List <LoadCombination> combinations = new List <LoadCombination>();
Dictionary <string, Loadcase> bhomCases = ReadLoadcase().ToDictionary(x => GetAdapterId <string>(x));
int nameCount = 0;
string[] nameArr = null;
m_model.RespCombo.GetNameList(ref nameCount, ref nameArr);
ids = FilterIds(ids, nameArr);
foreach (string id in ids)
{
LoadCombination bhomCombo = new LoadCombination();
double[] factors = null;
int caseCount = 0;
eCNameType[] caseTypes = null;
string[] caseNames = null;
if (m_model.RespCombo.GetCaseList(id, ref caseCount, ref caseTypes, ref caseNames, ref factors) != 0)
{
ReadElementError("Load Combo", id);
}
else
{
bhomCombo.Name = id;
if (caseCount > 0)
{
List <ICase> comboCases = new List <ICase>();
for (int j = 0; j < caseCount; j++)
{
comboCases.Add(bhomCases[caseNames[j]]);
bhomCombo.LoadCases.Add(new Tuple <double, ICase>(factors[j], comboCases[j]));
}
}
SetAdapterId(bhomCombo, id);
combinations.Add(bhomCombo);
}
}
return(combinations);
}
/***************************************************/
private List <LoadCombination> ReadLoadCombination(List <string> ids = null)
{
List <LoadCombination> combinations = new List <LoadCombination>();
//get all load cases before combinations
Dictionary <string, Loadcase> bhomCases = ReadLoadcase().ToDictionary(x => x.Name.ToString());
int nameCount = 0;
string[] nameArr = { };
m_model.RespCombo.GetNameList(ref nameCount, ref nameArr);
ids = FilterIds(ids, nameArr);
foreach (string id in ids)
{
LoadCombination combination = new LoadCombination();
string[] caseNames = null;
double[] factors = null;
int caseNum = 0;
eCNameType[] nameTypes = null;//<--TODO: maybe need to check if 1? (1=loadcombo)
if (m_model.RespCombo.GetCaseList(id, ref caseNum, ref nameTypes, ref caseNames, ref factors) == 0)
{
combination.Name = id;
if (caseNames != null)
{
Loadcase currentCase;
for (int i = 0; i < caseNames.Count(); i++)
{
if (bhomCases.TryGetValue(caseNames[i], out currentCase))
{
combination.LoadCases.Add(new Tuple <double, ICase>(factors[i], currentCase));
}
}
}
SetAdapterId(combination, id);
combinations.Add(combination);
}
}
return(combinations);
}
/// <summary>
/// Find out all Load Combination and Usage in the existing document.
/// As specification require, prepare some Load Combination Usages if they are not in document
/// </summary>
public void PrepareData()
{
// Find out all Load Combination and Usage in the existing document.
IList <Element> elements = (new FilteredElementCollector(m_document)).OfClass(typeof(LoadCombination)).ToElements();
foreach (Element elem in elements)
{
LoadCombination combination = elem as LoadCombination;
if (null != combination)
{
// Add the Load Combination name.
m_dataBuffer.LoadCombinationNames.Add(combination.Name);
// Create LoadCombinationMap object.
LoadCombinationMap combinationMap = new LoadCombinationMap(combination);
// Add the LoadCombinationMap object to the array list.
m_dataBuffer.LoadCombinationMap.Add(combinationMap);
}
}
elements = (new FilteredElementCollector(m_document)).OfClass(typeof(LoadUsage)).ToElements();
foreach (Element elem in elements)
{
// Add Load Combination Usage information
LoadUsage usage = elem as LoadUsage;
if (null != usage)
{
// Add the Load Usage name
m_dataBuffer.LoadUsageNames.Add(usage.Name);
// Add the Load Usage object to a LoadUsageArray
m_dataBuffer.LoadUsages.Add(usage);
// Add the Load Usage information to UsageMap.
UsageMap usageMap = new UsageMap(m_dataBuffer, usage.Name);
m_dataBuffer.UsageMap.Add(usageMap);
}
}
// As specification require, some Load Combination Usages if they are not in document
String[] initUsageArray = { "Gravity", "Lateral", "Steel", "Composite", "Concrete" };
foreach (String s in initUsageArray)
{
NewLoadUsage(s);
}
}
/***************************************************/
private bool CreateObject(LoadCombination loadcombination)
{
eCNameType nameType = eCNameType.LoadCase;
int caseNameCount = 0;
string[] caseNameArr = null;
m_model.LoadPatterns.GetNameList(ref caseNameCount, ref caseNameArr);
if (m_model.RespCombo.Add(loadcombination.Name, 0) == 0)
{
SetAdapterId(loadcombination, loadcombination.Name);
foreach (Tuple <double, ICase> comboCase in loadcombination.LoadCases)
{
double factor = comboCase.Item1;
ICase bhomCase = comboCase.Item2;
string caseName = "";
if (bhomCase.HasAdapterIdFragment(typeof(SAP2000Id)))
{
caseName = GetAdapterId <string>(bhomCase);
}
else if (caseNameArr.Contains(bhomCase.Name))
{
caseName = bhomCase.Name;
}
else
{
Engine.Base.Compute.RecordWarning($"case {bhomCase.Name} has no SAP2000_id, and no case with that name was found in the model. Try pushing the loadcase and using the result of that push to build the combo.");
}
if (m_model.RespCombo.SetCaseList(loadcombination.Name, ref nameType, caseName, factor) != 0)
{
Engine.Base.Compute.RecordWarning("Could not add case " + bhomCase.Name + " to combo " + loadcombination.Name);
}
}
}
else
{
CreateElementError("Load Combination", loadcombination.Name);
}
return(true);
}
/// <summary>
/// Gets the internal force at defined location.
/// tensor is in local coordinate system.
/// </summary>
/// <param name="xi">The xi.</param>
/// <param name="eta">The eta.</param>
/// <param name="combination">The locad combination.</param>
/// <returns>Stress tensor of flat shell, in local coordination system</returns>
/// <remarks>
/// for more info about local coordinate of flat shell see page [72 of 166] (page 81 of pdf) of "Development of Membrane, Plate and Flat Shell Elements in Java" thesis by Kaushalkumar Kansara freely available on the web
/// </remarks>
public FlatShellStressTensor GetInternalForce(double xi, double eta, LoadCombination combination)
{
var buf = new FlatShellStressTensor();
if (_behaviour == FlatShellBehaviour.Membrane || _behaviour == FlatShellBehaviour.ThinShell)
{
buf.MembraneTensor = GetMembraneInternalForce(xi, eta, combination);
}
;
if (_behaviour == FlatShellBehaviour.ThinPlate || _behaviour == FlatShellBehaviour.ThinShell)
{
buf.BendingTensor = GetBendingInternalForce(xi, eta, combination);
}
return(buf);
}
/***************************************************/
private List <LoadCombination> ReadLoadCombination(List <string> ids = null)
{
//Implement code for reading loadcombinations
List <LoadCombination> bhomLoadCombinations = new List <LoadCombination>();
ILoadCombinations ILoadCombinations = m_Model.GetLoadCombinations(COMBO_MATERIAL_TYPE.ANALYSIS_CUSTOM);
for (int i = 0; i < ILoadCombinations.GetCount(); i++)
{
//Get LoadCombinations
ILoadCombination ILoadCombination = ILoadCombinations.GetAt(i);
LoadCombination bhomLoadCombination = BH.Adapter.RAM.Convert.ToBHoMObject(m_Model, ILoadCombination);
bhomLoadCombinations.Add(bhomLoadCombination);
}
return(bhomLoadCombinations);
}
public StrainTensor GetBendingInternalStrain(double localX, double localY, LoadCombination cmb)
{
//step 1 : get transformation matrix
//step 2 : convert globals points to locals
//step 3 : convert global displacements to locals
//step 4 : calculate B matrix
//step 5 : e=B*U
//Note : Steps changed...
var trans = this.GetTransformationMatrix();
var lp = GetLocalPoints();
var g2l = new Func <Vector, Vector>(glob => (trans.Transpose() * glob.ToMatrix()).ToVector());
//var l2g = new Func<Vector, Vector>(local => (trans*local.ToMatrix()).ToPoint());
var d1g = this.nodes[0].GetNodalDisplacement(cmb);
var d2g = this.nodes[1].GetNodalDisplacement(cmb);
var d3g = this.nodes[2].GetNodalDisplacement(cmb);
//step 3
var d1l = new Displacement(g2l(d1g.Displacements), g2l(d1g.Rotations));
var d2l = new Displacement(g2l(d2g.Displacements), g2l(d2g.Rotations));
var d3l = new Displacement(g2l(d3g.Displacements), g2l(d3g.Rotations));
var uDkt =
new Matrix(new[]
{ d1l.DZ, d1l.RX, d1l.RY, /**/ d2l.DZ, d2l.RX, d2l.RY, /**/ d3l.DZ, d3l.RX, d3l.RY });
var b = DktElement.GetBMatrix(localX, localY,
lp.Select(i => i.X).ToArray(),
lp.Select(i => i.Y).ToArray());
var mDkt = b * uDkt;
var buf = new StrainTensor();
buf.S11 = mDkt[0, 0];
buf.S22 = mDkt[1, 0];
buf.S12 = mDkt[2, 0];
return(buf);
}
private double[] ReadMyDisplacementVector(LoadCombination allCmb)
{
var ds = new double[6 * model.Nodes.Count];
for (var i = 0; i < model.Nodes.Count; i++)
{
var d = model.Nodes[i].GetNodalDisplacement(allCmb);
ds[6 * i + 0] = d.DX;
ds[6 * i + 1] = d.DY;
ds[6 * i + 2] = d.DZ;
ds[6 * i + 3] = d.RX;
ds[6 * i + 4] = d.RY;
ds[6 * i + 5] = d.RZ;
}
return(ds);
}
private List <LoadCombination> ReadLoadCombination(List <string> ids = null)
{
// Linear Load Combinations !! Only !!
// only solver generated combinations
List <LoadCombination> loadCombinations = new List <LoadCombination>();
int err = 0;
int uID = 1;
int freedomCase = 1;
int loadComboCount = 0;
List <Loadcase> allLoadCases = ReadLoadcase();
err = St7.St7GetNumLSACombinations(uID, ref loadComboCount);
if (!St7ErrorCustom(err, "Could not get loadCombinations"))
{
return(loadCombinations);
}
for (int ldCombo = 1; ldCombo <= loadComboCount; ldCombo++)
{
StringBuilder loadComboName = new StringBuilder(St7.kMaxStrLen);
err = St7.St7GetLSACombinationName(uID, ldCombo, loadComboName, St7.kMaxStrLen);
if (!St7ErrorCustom(err, "Could not get a name of load combination " + ldCombo))
{
continue;
}
List <double> loadCaseFactors = new List <double>();
for (int j = 0; j < allLoadCases.Count; j++)
{
int loadcaseNum = GetAdapterId <int>(allLoadCases[j]);
double factor = 0;
err = St7.St7GetLSACombinationFactor(uID, St7.ltLoadCase, ldCombo, loadcaseNum, freedomCase, ref factor);
if (!St7ErrorCustom(err, "Could not get a factor for a loadcase " + loadcaseNum + " load combo " + ldCombo))
{
return(loadCombinations);
}
loadCaseFactors.Add(factor);
}
LoadCombination loadCombination = BH.Engine.Structure.Create.LoadCombination(loadComboName.ToString(), ldCombo, allLoadCases, loadCaseFactors);
SetAdapterId(loadCombination, ldCombo);
loadCombinations.Add(loadCombination);
}
return(loadCombinations);
}
private void Stream( ArrayList data, LoadCombination loadcombo )
{
data.Add( new Snoop.Data.ClassSeparator( typeof( LoadCombination ) ) );
data.Add( new Snoop.Data.String( "Name", loadcombo.Name ) );
data.Add( new Snoop.Data.Object( "Combination type", loadcombo.Type ) );
data.Add( new Snoop.Data.Object( "Combination state", loadcombo.State ) );
data.Add( new Snoop.Data.CategorySeparator( "Components" ) );
data.Add( new Snoop.Data.Int( "Number of components", loadcombo.GetComponents().Count ) );
foreach( var component in loadcombo.GetComponents() )
{
LoadCase cs = loadcombo.Document.GetElement( component.LoadCaseOrCombinationId ) as LoadCase;
if( cs != null )
{
data.Add( new Snoop.Data.String( "Combination case name", cs.Name ) );
data.Add( new Snoop.Data.ElementId( "Combination nature name", cs.NatureId, loadcombo.Document ) );
}
data.Add( new Snoop.Data.Double( "Factor", component.Factor ) );
}
data.Add( new Snoop.Data.CategorySeparator( "Usages" ) );
data.Add( new Snoop.Data.Int( "Number of usages", loadcombo.GetUsageIds().Count ) );
for( int i = 0; i < loadcombo.GetUsageIds().Count; i++ )
{
data.Add( new Snoop.Data.String( string.Format( "Usage name [{0:d}]", i ), loadcombo.Document.GetElement( loadcombo.GetUsageIds()[i] ).Name ) );
}
}
private void Stream( ArrayList data, LoadCombination loadcombo )
{
data.Add( new Snoop.Data.ClassSeparator( typeof( LoadCombination ) ) );
data.Add( new Snoop.Data.String( "Name", loadcombo.Name ) );
data.Add( new Snoop.Data.String( "Combination type", loadcombo.Type.ToString() ) );
data.Add( new Snoop.Data.String( "Combination state", loadcombo.State.ToString() ) );
data.Add( new Snoop.Data.CategorySeparator( "Components" ) );
data.Add( new Snoop.Data.Int( "Number of components", loadcombo.GetComponents().Count ) );
for( int i = 0; i < loadcombo.GetComponents().Count; i++ )
{
data.Add( new Snoop.Data.String( string.Format( "Combination case name [{0:d}]", i ), loadcombo.Document.GetElement( loadcombo.GetCaseAndCombinationIds()[i] ).Name ) );
data.Add( new Snoop.Data.String( string.Format( "Combination nature name [{0:d}]", i ), loadcombo.Document.GetElement( loadcombo.GetCaseAndCombinationIds()[i] ).Name ) );
data.Add( new Snoop.Data.Double( string.Format( "Factor [{0:d}]", i ), loadcombo.GetComponents()[i].Factor ) );
}
data.Add( new Snoop.Data.CategorySeparator( "Usages" ) );
data.Add( new Snoop.Data.Int( "Number of usages", loadcombo.GetUsageIds().Count ) );
for( int i = 0; i < loadcombo.GetUsageIds().Count; i++ )
{
data.Add( new Snoop.Data.String( string.Format( "Usage name [{0:d}]", i ), loadcombo.Document.GetElement( loadcombo.GetUsageIds()[i] ).Name ) );
}
}
private void Stream( ArrayList data, LoadCombination loadcombo )
{
data.Add( new Snoop.Data.ClassSeparator( typeof( LoadCombination ) ) );
data.Add( new Snoop.Data.String( "Name", loadcombo.Name ) );
data.Add( new Snoop.Data.String( "Combination type", loadcombo.CombinationType ) );
data.Add( new Snoop.Data.Int( "Combination type index", loadcombo.CombinationTypeIndex ) );
data.Add( new Snoop.Data.String( "Combination state", loadcombo.CombinationState ) );
data.Add( new Snoop.Data.Int( "Combination state index", loadcombo.CombinationStateIndex ) );
data.Add( new Snoop.Data.CategorySeparator( "Components" ) );
data.Add( new Snoop.Data.Int( "Number of components", loadcombo.NumberOfComponents ) );
for( int i = 0; i < loadcombo.NumberOfComponents; i++ )
{
data.Add( new Snoop.Data.String( string.Format( "Combination case name [{0:d}]", i ), loadcombo.get_CombinationCaseName( i ) ) );
data.Add( new Snoop.Data.String( string.Format( "Combination nature name [{0:d}]", i ), loadcombo.get_CombinationNatureName( i ) ) );
data.Add( new Snoop.Data.Double( string.Format( "Factor [{0:d}]", i ), loadcombo.get_Factor( i ) ) );
}
data.Add( new Snoop.Data.CategorySeparator( "Usages" ) );
data.Add( new Snoop.Data.Int( "Number of usages", loadcombo.NumberOfUsages ) );
for( int i = 0; i < loadcombo.NumberOfUsages; i++ )
{
data.Add( new Snoop.Data.String( string.Format( "Usage name [{0:d}]", i ), loadcombo.get_UsageName( i ) ) );
}
}
