/// <summary> /// Gets the 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="loadCase">The Load case.</param> /// <returns></returns> /// <remarks> /// Will calculate the internal forces of member regarding the <see cref="loadCase" /> /// </remarks> public virtual Force GetInternalForceAt(double xi, LoadCase loadCase) { var helpers = GetHelpers(); var lds = new Displacement[this.Nodes.Length]; var tr = this.GetTransformationManager(); for (var i = 0; i < Nodes.Length; i++) { var globalD = Nodes[i].GetNodalDisplacement(loadCase); var local = tr.TransformGlobalToLocal(globalD); lds[i] = local; } //var buff = new Force(); var frc = new Vector(); //forcec var mnt = new Vector(); //moment foreach (var helper in helpers) { var tns = helper.GetLocalInternalForceAt(this, lds, new[] { xi }); foreach (var tuple in tns) { switch (tuple.Item1) { case DoF.Dx: frc.X += tuple.Item2; break; case DoF.Dy: frc.Y += tuple.Item2; break; case DoF.Dz: frc.Z += tuple.Item2; break; case DoF.Rx: mnt.X += tuple.Item2; break; case DoF.Ry: mnt.Y += tuple.Item2; break; case DoF.Rz: mnt.Z += tuple.Item2; break; default: throw new ArgumentOutOfRangeException(); } } } return(new Force(frc, mnt)); }
/// <summary> /// Gets the 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="loadCase">The Load case.</param> /// <returns></returns> /// <remarks> /// Will calculate the internal forces of member regarding the <see cref="loadCase" /> /// </remarks> public Force GetExactInternalForceAt(double xi, LoadCase loadCase) { var approx = GetInternalForceAt(xi, loadCase); var buf = new FlatShellStressTensor(); var helpers = GetHelpers(); foreach (var load in this.Loads) { foreach (var helper in helpers) { var tns = helper.GetLoadInternalForceAt(this, load, new[] { xi }); //buf = buf + tns; } } var buff = new Force(); var forces = new Vector(buf.MembraneTensor.S11, buf.MembraneTensor.S12, buf.MembraneTensor.S13); //Fx, Vy, Vz var moments = new Vector(buf.BendingTensor.M11, buf.BendingTensor.M12, buf.BendingTensor.M13); //Mx, My, Mz return(new Force(forces, moments) + approx); }
private void AddLoadCasesToOpenModel() { LoadCase loadCase = new LoadCase(); loadCase.Name = "LC1"; loadCase.Id = 1; loadCase.Type = LoadCaseSubType.PermanentStandard; LoadGroupEC loadGroup = null; loadGroup = new LoadGroupEC(); loadGroup.Id = 1; loadGroup.Name = "LG1"; loadGroup.GammaQ = 1.5; loadGroup.Psi0 = 0.7; loadGroup.Psi1 = 0.5; loadGroup.Psi2 = 0.3; loadGroup.GammaGInf = 1.0; loadGroup.GammaGSup = 1.35; loadGroup.Dzeta = 0.85; openStructModel.AddObject(loadGroup); loadCase.LoadGroup = new ReferenceElement(loadGroup); openStructModel.AddObject(loadCase); }
/// <summary> /// Duplicate a new load case /// </summary> /// <param name="index"></param> /// <returns></returns> public bool DuplicateLoadCase(int index) { LoadCasesMap myLoadCase = null; bool isUnique = false; string caseName = null; //try to get the load case from the map try { myLoadCase = m_dataBuffer.LoadCasesMap[index]; } catch (Exception e) { m_dataBuffer.ErrorInformation += e.ToString(); return(false); } //get nothing if (null == myLoadCase) { m_dataBuffer.ErrorInformation += "Can not find the load case"; return(false); } //check the name caseName = myLoadCase.LoadCasesName; while (!isUnique) { caseName += "(1)"; isUnique = IsCaseNameUnique(caseName); } //get the selected case's nature Autodesk.Revit.DB.Structure.LoadNatureCategory natureCategory = myLoadCase.LoadNatureCategory; Autodesk.Revit.DB.ElementId natureId = myLoadCase.LoadCasesNatureId; UIApplication uiapplication = new UIApplication(m_revit); //try to create a load case try { LoadCase newLoadCase = LoadCase.Create(uiapplication.ActiveUIDocument.Document, caseName, natureId, natureCategory); if (null == newLoadCase) { m_dataBuffer.ErrorInformation += "Create Load Case Failed"; return(false); } //add the new case into list and map m_dataBuffer.LoadCases.Add(newLoadCase); LoadCasesMap newLoadCaseMap = new LoadCasesMap(newLoadCase); m_dataBuffer.LoadCasesMap.Add(newLoadCaseMap); } catch (Exception e) { m_dataBuffer.ErrorInformation += e.ToString(); return(false); } return(true); }
public override NodalResponse SuperimposeResponsesAtLoadCase(LoadCase loadCase) { NodalResponse response = base.SuperimposeResponsesAtLoadCase(loadCase); response.Coordinate = Coordinate; return(response); }
/// <summary> /// Overload the constructor /// </summary> /// <param name="loadCase">Load Case</param> public LoadCasesMap(LoadCase loadCase) { m_loadCase = loadCase; m_loadCasesName = m_loadCase.Name; m_loadCasesNumber = m_loadCase.Number.ToString(); m_loadCasesNatureId = m_loadCase.NatureId; m_loadCasesSubcategoryId = m_loadCase.SubcategoryId; }
public override ShearWallPanelResponse SuperimposeResponsesAtLoadCase(LoadCase loadCase) { ShearWallPanelResponse response = base.SuperimposeResponsesAtLoadCase(loadCase); response.WallLocation = WallLocation; return(response); }
/// <summary> /// Retrieves the modal case assigned to the analysis case. /// </summary> /// <exception cref="CSiException"><see cref="CSiApiBase.API_DEFAULT_ERROR_CODE" /></exception> public void FillModalCase() { LoadCase loadCase = _loadCases.FillItem(_appGet?.GetModalCase(CaseName)); if (loadCase is ModalEigen modalEigen) { _modalCase = modalEigen; } }
public static void Run1() { double h = 5; Node n1 = new Node(0, 0, 0); Node n2 = new Node(h, 0, 0); n1.Constraints = Constraints.Fixed; var section = new UniformGeometric1DSection(SectionGenerator.GetRectangularSection(1, 0.5)); var material = UniformIsotropicMaterial.CreateFromYoungShear(205e9, 81e9); BarElement e = new BarElement(n1, n2) { Section = section, Material = material }; e.Behavior = BarElementBehaviours.FullFrame; var lc1 = new LoadCase("C1", LoadType.Dead); var lc2 = new LoadCase("C2", LoadType.Live); var lc3 = new LoadCase("C3", LoadType.Live); var load = new UniformLoad() { Direction = Vector.FromXYZ(0, 0, -1), CoordinationSystem = CoordinationSystem.Global, Magnitude = 1, Case = lc1 }; var load2 = new UniformLoad() { Direction = Vector.FromXYZ(1, 0, 0), CoordinationSystem = CoordinationSystem.Global, Magnitude = 10, Case = lc2 }; var load3 = new ConcentratedLoad(new Force(0, 0, 0, 00, 10, 00), new IsoPoint(0.50), CoordinationSystem.Local); load3.Case = lc3; e.Loads.Add(load); e.Loads.Add(load2); e.Loads.Add(load3); Model model = new Model(); model.Nodes.Add(n1); model.Nodes.Add(n2); model.Elements.Add(e); model.Solve_MPC(); BarInternalForceVisualizer.VisualizeInNewWindow(e); }
public void DoTheBenchmark() { var sw = Stopwatch.StartNew(); var st = GetCaseModel(); var case1 = new LoadCase("c1", LoadType.Other); var case2 = new LoadCase("c2", LoadType.Other); foreach (var nde in st.Nodes) { nde.Loads.Add(new NodalLoad(Util.GetRandomForce(), case1)); nde.Loads.Add(new NodalLoad(Util.GetRandomForce(), case2)); } var type = SolverType; var conf = new SolverConfiguration { //SolverGenerator = i => CalcUtil.CreateBuiltInSolver(type, i), SolverFactory = CalcUtil.CreateBuiltInSolverFactory(type) }; GC.Collect(); Logger.Log(""); Logger.Log("\tSolver type: {0}", Util.GetEnumDescription(SolverType)); try { st.Solve(conf); sw.Restart(); st.LastResult.AddAnalysisResultIfNotExists(case1); sw.Stop(); Logger.Log("\t\tgeneral solve time: {0}", sw.Elapsed); sw.Restart(); st.LastResult.AddAnalysisResultIfNotExists(case2); sw.Stop(); Logger.Log("\t\textra solve time per LoadCase: {0}", sw.Elapsed); } catch (Exception ex) { Logger.Log("\t\tFailed, err = {0}", ex.Message); } sw.Stop(); GC.Collect(); }
private static string CreateLoadNode(LoadCase loadCase) { // units are Newtons [N] for loads and Newton Millimetres for moments [N.mm] #if false text file version below, we'll emit csv nF # number of loaded nodes (global) .node X-load Y-load Z-load X-mom Y-mom Z-mom N N N N.mm N.mm N.mm N[1] Fx[1] Fy[1] Fz[1] Mxx[1] Myy[1] Mzz[1]
public static void CheckModel_mpc(Model model, LoadCase lc) { var n = model.Nodes.Count * 6; //model.ReIndexNodes(); //LoadCase.DefaultLoadCase var perm = CalcUtil.GenerateP_Delta_Mpc(model, lc, new Mathh.GaussRrefFinder()); var np = perm.Item1.ColumnCount;//master count var rd = perm.Item2; var pd = perm.Item1; var kt = MatrixAssemblerUtil.AssembleFullStiffnessMatrix(model); if (perm.Item1.RowCount > 0 && perm.Item1.RowCount > 0) { var pf = pd.Transpose(); var kr = pf.Multiply(kt).Multiply(pd); var nr = kr.RowCount; for (int i = 0; i < nr; i++) { //two conditions: // 1 - DoF[i] in reduced structure is a member of bounded dof group with MPC equations // 2 - DoF[i] in reduced structure is not in first condition, it is standalone and not related to any other DoF or Fixed Value var t = kr.At(i, i); if (t > 0) { continue; } var nodeNum = 6.0 / 6; if (t == 0) { model.Trace.Write(Common.TraceLevel.Warning, "DoF {0} of Node {1} not properly constrained", 7 % 6, nodeNum); } else//t < 0 { model.Trace.Write(Common.TraceLevel.Warning, "DoF {0} of Node {1} not member", 7 % 6, nodeNum); } } } }
public override bool Execute(ExecutionInfo exInfo = null) { LoadCase lCase = Model.LoadCases.FindByName(Name); if (lCase == null || lCase.IsDeleted) { lCase = Model.Create.LoadCase(Name, exInfo); } lCase.CaseType = Type; return(true); }
//TODO Only a mockup implementation ready //This method creates a load case private static LoadCase[] LoadCases() { LoadCase lCase = new LoadCase(); lCase.SelfWeight = false; lCase.Loading.No = 1; LoadCase[] lCaseArray = { lCase }; return(lCaseArray); }
static void Main() { // PRACTICAL EXAMPLE: SETTING UP LOAD GROUPS // This example shows the core steps of creating load groups for a model. // This example was last updated 2022-04-06, using the ver. 21.1.0 FEM-Design API. // CREATING LOAD CASES LoadCase deadLoad1 = new LoadCase("Deadload1", LoadCaseType.DeadLoad, LoadCaseDuration.Permanent); LoadCase deadLoad2 = new LoadCase("Deadload2", LoadCaseType.DeadLoad, LoadCaseDuration.Permanent); LoadCase liveLoad1 = new LoadCase("Liveload1", LoadCaseType.Static, LoadCaseDuration.Permanent); LoadCase liveLoad2 = new LoadCase("Liveload2", LoadCaseType.Static, LoadCaseDuration.Permanent); List <LoadCase> loadCasesDeadLoads = new List <LoadCase>() { deadLoad1, deadLoad2 }; List <LoadCase> loadCaseLiveLoads = new List <LoadCase>() { liveLoad1, liveLoad2 }; // FETCHING LOAD CATEGORY DATABASE var loadCategoryDatabase = LoadCategoryDatabase.GetDefault(); LoadCategory loadCategory = loadCategoryDatabase.LoadCategoryByName("A"); // CREATING LOAD GROUPS var LG1 = new ModelGeneralLoadGroup(new LoadGroupPermanent(1, 1.35, 1, 1, loadCasesDeadLoads, ELoadGroupRelationship.Simultaneous, 0.89, "LG1")); var LG2 = new ModelGeneralLoadGroup(new LoadGroupTemporary(1.5, loadCategory.Psi0, loadCategory.Psi1, loadCategory.Psi2, true, loadCaseLiveLoads, ELoadGroupRelationship.Alternative, "LG2")); var loadGroups = new List <ModelGeneralLoadGroup>() { LG1, LG2 }; // CREATING AND OPENING NEW MODEL var model2 = new Model(Country.S, null, null, loadCasesDeadLoads.Concat(loadCaseLiveLoads).ToList(), null, loadGroups); string path = Path.GetFullPath("output/LoadGroups.struxml"); if (!Directory.Exists("output")) { Directory.CreateDirectory("output"); } model2.SerializeModel(path); var app = new Calculate.Application(); app.OpenStruxml(path, true); }
public static void CheckModel(Model model, LoadCase lc) { model.ReIndexNodes(); //LoadCase.DefaultLoadCase var fullst = MatrixAssemblerUtil.AssembleFullStiffnessMatrix(model); var mgr = DofMappingManager.Create(model, lc); var dvd = CalcUtil.GetReducedZoneDividedMatrix(fullst, mgr); var stiffness = dvd.ReleasedReleasedPart; var n = stiffness.ColumnCount; for (int i = 0; i < n; i++) { var t = stiffness.At(i, i); if (t > 0) { continue; } var m1 = mgr.RMap2[i]; var m2 = mgr.RMap1[m1]; var nodeNum = m2 / 6; if (t == 0) { model.Trace.Write(Common.TraceLevel.Warning, "DoF {0} of Node {1} not properly constrained", m2 % 6, nodeNum); } else//t < 0 { model.Trace.Write(Common.TraceLevel.Warning, "DoF {0} of Node {1} not member", m2 % 6, nodeNum); } } var k = MatrixAssemblerUtil.AssembleFullStiffnessMatrix(model); //CalcUtil.MakeMatrixSymetric(k); var kt = k.Transpose(); Enumerable.Range(0, k.Values.Length).ToList().ForEach(i => kt.Values[i] = -kt.Values[i]); var sym = k.Add(kt); var max = sym.Values.Max(i => Math.Abs(i)); }
public GeneralStressTensor GetLocalInternalForce(Element targetElement, LoadCase loadCase, params double[] isoCoords) { //step 1 : get transformation matrix //step 2 : convert globals points to locals //step 3 : convert global displacements to locals //step 4 : calculate B matrix and D matrix //step 5 : M=D*B*U //Note : Steps changed... var lds = new Displacement[targetElement.Nodes.Length]; var tr = targetElement.GetTransformationManager(); for (var i = 0; i < targetElement.Nodes.Length; i++) { var globalD = targetElement.Nodes[i].GetNodalDisplacement(loadCase); var local = tr.TransformGlobalToLocal(globalD); lds[i] = local; } var b = GetBMatrixAt(targetElement, isoCoords); var d = GetDMatrixAt(targetElement, isoCoords); var u1l = lds[0]; var u2l = lds[1]; var u3l = lds[2]; var uDkt = targetElement.MatrixPool.Allocate(new[] { u1l.DZ, u1l.RX, u1l.RY, /**/ u2l.DZ, u2l.RX, u2l.RY, /**/ u3l.DZ, u3l.RX, u3l.RY }); var mDkt = d * b * uDkt; //eq. 32, batoz article //var buf = new PlateBendingStressTensor(); //buf.Mx = mDkt[0, 0]; //buf.My = mDkt[1, 0]; //buf.Mxy = mDkt[2, 0]; //return buf; var bTensor = new BendingStressTensor(); //var buf = new List<Tuple<DoF, double>>(); bTensor.M11 = mDkt[0, 0]; bTensor.M22 = mDkt[1, 0]; bTensor.M21 = bTensor.M12 = mDkt[2, 0]; var buf = new GeneralStressTensor(bTensor); return(buf); }
/// <summary> /// Gets the internal stress at defined <see cref="isoLocation"/>. /// tensor is in local coordinate system. /// </summary> /// <param name="loadCase">the load case </param> /// <param name="isoLocation"></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 CauchyStressTensor GetLocalInternalStress(LoadCase loadCase, double[] isoLocation) { var helpers = GetHelpers(); var gst = new GeneralStressTensor(); var tr = this.GetTransformationManager(); var ld = this.Nodes.Select(i => tr.TransformGlobalToLocal(i.GetNodalDisplacement(loadCase))).ToArray(); for (var i = 0; i < helpers.Count(); i++) { var st = helpers[i].GetLocalInternalStressAt(this, ld, isoLocation); gst += st; } var buf = new CauchyStressTensor(); buf += gst.MembraneTensor; { //step2: update Cauchy based on bending, //bending tensor also affects the Cauchy tensor regarding how much distance between desired location and center of plate. //old code: buf.UpdateTotalStress(_section.GetThicknessAt(new double[] { localX, localY }) * localZ, probeLocation); var lambda = 0.0; if (isoLocation.Length == 3) { lambda = isoLocation[2]; } if (lambda > 1.0 || lambda < -1.0) { throw new Exception("lambda must be between -1 and +1") { }; } var thickness = Section.GetThicknessAt(isoLocation); var z = thickness * lambda;//distance from plate center, measure in [m] if (lambda > 0) { //top -> add bending stress buf += gst.BendingTensor.ConvertBendingStressToCauchyTensor(z); } else { //bottom -> subtract bending stress buf -= gst.BendingTensor.ConvertBendingStressToCauchyTensor(z); } } return(buf); }
/// <summary> /// prepare data for the dialog /// </summary> public void PrepareData() { //Create seven Load Natures first if (!CreateLoadNatures()) { return; } //get all the categories of load cases UIApplication uiapplication = new UIApplication(m_revit); Categories categories = uiapplication.ActiveUIDocument.Document.Settings.Categories; Category category = categories.get_Item(BuiltInCategory.OST_LoadCases); CategoryNameMap categoryNameMap = category.SubCategories; System.Collections.IEnumerator iter = categoryNameMap.GetEnumerator(); iter.Reset(); while (iter.MoveNext()) { Category temp = iter.Current as Category; if (null == temp) { continue; } m_dataBuffer.LoadCasesCategory.Add(temp); } //get all the loadnatures name IList <Element> elements = new FilteredElementCollector(uiapplication.ActiveUIDocument.Document).OfClass(typeof(LoadNature)).ToElements(); foreach (Element e in elements) { LoadNature nature = e as LoadNature; if (null != nature) { m_dataBuffer.LoadNatures.Add(nature); LoadNaturesMap newLoadNaturesMap = new LoadNaturesMap(nature); m_dataBuffer.LoadNaturesMap.Add(newLoadNaturesMap); } } elements = new FilteredElementCollector(uiapplication.ActiveUIDocument.Document).OfClass(typeof(LoadCase)).ToElements(); foreach (Element e in elements) { //get all the loadcases LoadCase loadCase = e as LoadCase; if (null != loadCase) { m_dataBuffer.LoadCases.Add(loadCase); LoadCasesMap newLoadCaseMap = new LoadCasesMap(loadCase); m_dataBuffer.LoadCasesMap.Add(newLoadCaseMap); } } }
protected override void SolveInstance(IGH_DataAccess DA) { // get data Brep surface = null; Vector3d direction = Vector3d.Zero; LoadCase loadCase = null; double z0 = 0, q0 = 0, qh = 0; string comment = null; if (!DA.GetData(0, ref surface)) { return; } if (!DA.GetData(1, ref direction)) { return; } if (!DA.GetData(2, ref loadCase)) { return; } if (!DA.GetData(3, ref z0)) { return; } if (!DA.GetData(4, ref q0)) { return; } if (!DA.GetData(5, ref qh)) { return; } if (!DA.GetData(6, ref comment)) { // pass } if (surface == null || loadCase == null) { return; } // transform geometry FemDesign.Geometry.Region region = surface.FromRhino(); FemDesign.Geometry.FdVector3d loadDirection = direction.FromRhino().Normalize(); PressureLoad obj = new PressureLoad(region, loadDirection, z0, q0, qh, loadCase, comment, false, ForceLoadType.Force); // return DA.SetData(0, obj); }
/// <summary> /// Find a load case by the load case name /// </summary> /// <param name="name">The name of load case</param> /// <returns>The reference of the LoadCase</returns> private LoadCase FindLoadCaseByName(String name) { LoadCase loadCase = null; foreach (LoadCase l in m_dataBuffer.LoadCases) { if (name == l.Name) { loadCase = l; break; } } return(loadCase); }
// TODO: For SAP2000 ///// <summary> ///// The output option for power spectral density results. ///// SAP2000 only. ///// </summary> ///// <value>The output PSD option.</value> //eAnalysisPSDOptions OutputPSDOption { get; internal set; } ///// <summary> ///// The output option for steady state results. ///// SAP2000 only. ///// </summary> ///// <value>The output steady state option.</value> //eAnalysisSteadyStateOptions OutputSteadyStateOption { get; internal set; } ///// <summary> ///// The steady state option. ///// SAP2000 only. ///// </summary> ///// <value>The steady state option.</value> //eSteadyStateOptions SteadyStateOption { get; internal set; } #endregion #region Fill/Set /// <summary> /// Sets the case selected for output. /// </summary> /// <param name="loadCase">An existing load case.</param> public void SetCaseSelectedForOutput(LoadCase loadCase) { if (loadCase.IsSelectedForAnalysis) { if (!CasesSelectedForOutput.Contains(loadCase)) { CasesSelectedForOutput.Add(loadCase); } } else { CasesSelectedForOutput.Remove(loadCase); } }
private void addLoadDeflection(AbstractCase ac, LineElement line, float lineLength, float[,] controlPoints, DeformationAxis component, float scale, float EI) { if (ac == null) { return; } if (ac is LoadCombination) { foreach (AbstractCaseFactor acf in ((LoadCombination)ac).Cases) { addLoadDeflection(acf.Case, line, lineLength, controlPoints, component, acf.Factor, EI); } } else if (ac is AnalysisCase) { if (((AnalysisCase)ac).Properties is StaticCaseProps) { foreach (StaticCaseFactor staticCase in ((StaticCaseProps)((AnalysisCase)ac).Properties).Loads) { if (staticCase.AppliedLoad is LoadCase) { LoadCase lc = staticCase.AppliedLoad as LoadCase; if (line.Loads[lc] != null) { foreach (Load load in line.Loads[lc]) { //addUniformLoadDeflection(line, lineLength, load as LineLoad, controlPoints, component, scale, EI); //addTriangularLoadDeflection(line, lineLength, load as LineLoad, controlPoints, component, scale, EI); if (load is DirectionalLineLoad) { addLoadDeflection(line, lineLength, load as DirectionalLineLoad, controlPoints, component, scale, EI); } } } if (lc.SelfWeight > 0f) { if (line.Properties is StraightFrameProps) { StraightFrameProps frameProps = line.Properties as StraightFrameProps; selfWeight.La = selfWeight.Lb = frameProps.Section.Area * frameProps.Section.Material.UnitWeight; //addUniformLoadDeflection(line, lineLength, selfWeight, controlPoints, component, lc.SelfWeight * scale, EI); addLoadDeflection(line, lineLength, selfWeight, controlPoints, component, lc.SelfWeight * scale, EI); } } } } } } }
public RFLoadCase(LoadCase load) { Comment = load.Comment; ID = load.ID; IsValid = load.IsValid; No = load.Loading.No; Tag = load.Tag; ToSolve = load.ToSolve; Description = load.Description; ActionCategory = load.ActionCategory; SelfWeightFactor = new Vector3d(load.SelfWeightFactor.ToPoint3d()); ToModify = false; ToDelete = false; }
public EditLoadCaseDialog(LoadCase loadCase) { load = loadCase; InitializeComponent(); foreach (LoadCase.LoadCaseType type in Enum.GetValues(typeof(LoadCase.LoadCaseType))) { caseTypes.Add(Culture.Get(type.ToString()), type); } foreach (string type in caseTypes.Keys) { typeComboBox.Items.Add(type); } }
/// <summary> /// Sets the case selected for output. /// </summary> /// <param name="loadCase">An existing load case.</param> /// <exception cref="CSiException"><see cref="CSiApiBase.API_DEFAULT_ERROR_CODE" /></exception> /// <exception cref="MPT.CSI.API.Core.Support.CSiException"></exception> public void SetCaseSelectedForOutput(LoadCase loadCase) { _analysisResultsSetup.SetCaseSelectedForOutput(loadCase.Name, loadCase.IsSelectedForAnalysis); if (loadCase.IsSelectedForAnalysis) { if (!CasesSelectedForOutput.Contains(loadCase)) { CasesSelectedForOutput.Add(loadCase); } } else { CasesSelectedForOutput.Remove(loadCase); } }
private void addToShearMomentDiagram(AbstractCase ac, LineElement line, float[,] controlPoints, LineForceComponent component, float scale) { if (ac == null) { return; } if (ac is LoadCombination) { foreach (AbstractCaseFactor acf in ((LoadCombination)ac).Cases) { addToShearMomentDiagram(acf.Case, line, controlPoints, component, acf.Factor); } } else if (ac is AnalysisCase) { if (((AnalysisCase)ac).Properties is StaticCaseProps) { foreach (StaticCaseFactor staticCase in ((StaticCaseProps)((AnalysisCase)ac).Properties).Loads) { if (staticCase.AppliedLoad is LoadCase) { LoadCase lc = staticCase.AppliedLoad as LoadCase; if (line.Loads[lc] != null) { foreach (Load load in line.Loads[lc]) { if (load is DirectionalLineLoad) { addToShearMomentDiagram(line, load as DirectionalLineLoad, controlPoints, component, scale); } } } if (lc.SelfWeight > 0f) { if (line.Properties is StraightFrameProps) { StraightFrameProps frameProps = line.Properties as StraightFrameProps; selfWeight.La = selfWeight.Lb = frameProps.Section.Area * frameProps.Section.Material.UnitWeight; addToShearMomentDiagram(line, selfWeight, controlPoints, component, lc.SelfWeight * scale); } } } } } } }
public override bool Execute(ExecutionInfo exInfo = null) { LoadCase lCase = Model.LoadCases.FindByName(Case); if (lCase == null) { lCase = Model.Create.LoadCase(Case, exInfo); } NodeLoad nLoad = Model.Create.NodeLoad(lCase, exInfo); nLoad.Name = Name; nLoad.AppliedTo.Set(ApplyTo); nLoad.SetForce(Force); Load = nLoad; return(true); }
/// <summary> /// Relocates a ConcentratedSpanLoad between the line element where it is and a new adjacent line element. /// </summary> /// <param name="newLineLoads">The AssignedLoads object of the new Line Element</param> /// <param name="lc">The Load Case to which the load belongs.</param> /// <param name="x">The dividing point of the two line elements [0, 1]</param> /// <param name="load">The Load to distribute in two elements</param> /// <returns>true if the load was moved to the new Line Element (so the caller removes it). false otherwise.</returns> private static bool RelocateConcentratedLoads(AssignedLoads newLineLoads, LoadCase lc, float x, ConcentratedSpanLoad load) { if (x > load.D) { load.D = load.D / x; return(false); } else { load = (ConcentratedSpanLoad)load.Clone(); load.Id = 0; load.D = (load.D - x) / (1f - x); newLineLoads.Add(load, lc); return(true); } }
public LoadCase LoadPatternCaseToSpeckle(string loadPatternName) { //Converts just the load case name var speckleLoadCase = new LoadCase(); speckleLoadCase.loadType = GetAndConvertEtabsLoadType(loadPatternName); speckleLoadCase.name = loadPatternName; if (!SpeckleModel.loads.Contains(speckleLoadCase)) { } else { SpeckleModel.loads.Add(speckleLoadCase); } return(speckleLoadCase); }
string m_loadCasesNumber; //Store the load cases number #endregion Fields #region Constructors /// <summary> /// Overload the constructor /// </summary> /// <param name="loadCase">Load Case</param> public LoadCasesMap(LoadCase loadCase) { m_loadCase = loadCase; m_loadCasesName = m_loadCase.Name; FindProperty(); }
private void Stream( ArrayList data, LoadCase loadcase ) { data.Add( new Snoop.Data.ClassSeparator( typeof( LoadCase ) ) ); // Nothing at this level yet! }
private void Stream( ArrayList data, LoadCase loadcase ) { data.Add( new Snoop.Data.ClassSeparator( typeof( LoadCase ) ) ); // Nothing at this level yet! data.Add( new Snoop.Data.ElementId( "NatureId", loadcase.NatureId, loadcase.Document ) ); data.Add( new Snoop.Data.ElementId( "SubcategoryId", loadcase.SubcategoryId, loadcase.Document ) ); data.Add( new Snoop.Data.Int( "Number", loadcase.Number ) ); }