Exemplo n.º 1
0
        public static bool St7SetNodeLoad_Id(int loadCase, int nodeId, oM.Geometry.Vector force, oM.Geometry.Vector moment, bool active = false)
        {
            if (!active)
            {
                return(false);
            }
            int err;
            int uID = 1;

            double[] forces  = new double[3];
            double[] moments = new double[3];
            forces[0]  = force.X;
            forces[1]  = force.Y;
            forces[2]  = force.Z;
            moments[0] = moment.X;
            moments[1] = moment.Y;
            moments[2] = moment.Z;
            err        = St7.St7SetNodeForce3(uID, nodeId, loadCase, forces);
            if (!St7ErrorCustom(err, "Couldn't set point load for a loadcase " + loadCase + " node " + nodeId))
            {
                return(false);
            }
            err = St7.St7SetNodeMoment3(uID, nodeId, loadCase, moments);
            if (!St7ErrorCustom(err, "Couldn't set point load for a loadcase " + loadCase + " node " + nodeId))
            {
                return(false);
            }
            return(true);
        }
Exemplo n.º 2
0
        /***************************************************/

        public static void CopyCharacteristics(this IMaterialFragment toMaterial, StructuralAsset fromAsset)
        {
            double density = fromAsset.Density.ToSI(UnitType.UT_MassDensity);

#if (REVIT2020 || REVIT2021)
#else
            double dampingRatio = fromAsset.DampingRatio;
#endif

            oM.Geometry.Vector youngsModulus         = BH.Engine.Geometry.Create.Vector(fromAsset.YoungModulus.X.ToSI(UnitType.UT_Stress), fromAsset.YoungModulus.Y.ToSI(UnitType.UT_Stress), fromAsset.YoungModulus.Z.ToSI(UnitType.UT_Stress));
            oM.Geometry.Vector thermalExpansionCoeff = BH.Engine.Geometry.Create.Vector(fromAsset.ThermalExpansionCoefficient.X.ToSI(UnitType.UT_ThermalExpansion), fromAsset.ThermalExpansionCoefficient.Y.ToSI(UnitType.UT_ThermalExpansion), fromAsset.ThermalExpansionCoefficient.Z.ToSI(UnitType.UT_ThermalExpansion));
            oM.Geometry.Vector poissonsRatio         = BH.Engine.Geometry.Create.Vector(fromAsset.PoissonRatio.X, fromAsset.PoissonRatio.Y, fromAsset.PoissonRatio.Z);
            oM.Geometry.Vector shearModulus          = BH.Engine.Geometry.Create.Vector(fromAsset.ShearModulus.X.ToSI(UnitType.UT_Stress), fromAsset.ShearModulus.Y.ToSI(UnitType.UT_Stress), fromAsset.ShearModulus.Z.ToSI(UnitType.UT_Stress));

            toMaterial.Density = density;
#if (REVIT2020 || REVIT2021)
#else
            toMaterial.DampingRatio = dampingRatio;
#endif

            if (toMaterial is Aluminium)
            {
                Aluminium material = toMaterial as Aluminium;
                material.YoungsModulus         = youngsModulus.X;
                material.ThermalExpansionCoeff = thermalExpansionCoeff.X;
                material.PoissonsRatio         = poissonsRatio.X;
            }
            else if (toMaterial is Concrete)
            {
                Concrete material = toMaterial as Concrete;
                material.YoungsModulus         = youngsModulus.X;
                material.ThermalExpansionCoeff = thermalExpansionCoeff.X;
                material.PoissonsRatio         = poissonsRatio.X;
            }
            else if (toMaterial is Steel)
            {
                Steel material = toMaterial as Steel;
                material.YoungsModulus         = youngsModulus.X;
                material.ThermalExpansionCoeff = thermalExpansionCoeff.X;
                material.PoissonsRatio         = poissonsRatio.X;
            }
            else if (toMaterial is Timber)
            {
                Timber material = toMaterial as Timber;
                material.YoungsModulus         = youngsModulus;
                material.ThermalExpansionCoeff = thermalExpansionCoeff;
                material.PoissonsRatio         = poissonsRatio;
            }
            else if (toMaterial is GenericIsotropicMaterial)
            {
                GenericIsotropicMaterial material = toMaterial as GenericIsotropicMaterial;
                material.YoungsModulus         = youngsModulus.X;
                material.ThermalExpansionCoeff = thermalExpansionCoeff.X;
                material.PoissonsRatio         = poissonsRatio.X;
            }
        }
Exemplo n.º 3
0
        /***************************************************/
        /**** Public Methods                            ****/
        /***************************************************/

        public static IMaterialFragment FromRFEM(this rf.Material material)
        {
            IMaterialFragment bhMaterial = null;

            string[]     stringArr = material.TextID.Split('@');
            MaterialType matType   = material.GetMaterialType();// Engine.Adapters.RFEM.Query.GetMaterialType(material);
            string       matName   = Engine.Adapters.RFEM.Query.GetMaterialName(material);

            switch (matType)
            {
            case MaterialType.Aluminium:
                bhMaterial = Engine.Structure.Create.Aluminium(matName);
                break;

            case MaterialType.Steel:
                bhMaterial = Engine.Structure.Create.Steel(matName);
                break;

            case MaterialType.Concrete:
                bhMaterial = Engine.Structure.Create.Concrete(matName);
                break;

            case MaterialType.Timber:    //TODO: as this uses vector over double assumption is the the below turns Timber into an incorrect Isotropic material !!!
                BH.oM.Geometry.Vector young = new oM.Geometry.Vector()
                {
                    X = material.ElasticityModulus, Y = material.ElasticityModulus, Z = material.ElasticityModulus
                };
                BH.oM.Geometry.Vector poissons = new oM.Geometry.Vector()
                {
                    X = material.PoissonRatio, Y = material.PoissonRatio, Z = material.PoissonRatio
                };
                BH.oM.Geometry.Vector shear = new oM.Geometry.Vector()
                {
                    X = material.ShearModulus, Y = material.ShearModulus, Z = material.ShearModulus
                };
                BH.oM.Geometry.Vector thermal = new oM.Geometry.Vector()
                {
                    X = material.ThermalExpansion, Y = material.ThermalExpansion, Z = material.ThermalExpansion
                };
                bhMaterial = Engine.Structure.Create.Timber(matName, young, poissons, shear, thermal, material.SpecificWeight, 0.05);
                break;

            case MaterialType.Rebar:
            case MaterialType.Tendon:
            case MaterialType.Glass:
            case MaterialType.Cable:
            case MaterialType.Undefined:
            default:
                break;
            }

            bhMaterial.SetAdapterId(typeof(RFEMId), material.No);
            return(bhMaterial);
        }
Exemplo n.º 4
0
        /***************************************************/
        /****               Public Methods              ****/
        /***************************************************/

        public static oM.Geometry.Basis BasisFromRevit(this Transform transform)
        {
            if (transform == null)
            {
                return(null);
            }

            BH.oM.Geometry.Vector x = new oM.Geometry.Vector {
                X = transform.BasisX.X, Y = transform.BasisX.Y, Z = transform.BasisX.Z
            };
            BH.oM.Geometry.Vector y = new oM.Geometry.Vector {
                X = transform.BasisY.X, Y = transform.BasisY.Y, Z = transform.BasisY.Z
            };
            BH.oM.Geometry.Vector z = new oM.Geometry.Vector {
                X = transform.BasisZ.X, Y = transform.BasisZ.Y, Z = transform.BasisZ.Z
            };
            return(new oM.Geometry.Basis(x, y, z));
        }
Exemplo n.º 5
0
        public static CoordSystems St7GetUCSs(bool active = false)
        {
            if (!active)
            {
                return(new CoordSystems(false, new List <Cartesian>()));
            }
            int err;
            int uID     = 1;
            int num_UCS = 0;

            err = St7.St7GetNumUCS(uID, ref num_UCS);
            if (!St7Error(err))
            {
                return(new CoordSystems(false, new List <Cartesian>()));
            }
            int UCSType           = St7.csCartesian;
            List <Cartesian> UCSs = new List <Cartesian>();

            for (int i = 1; i <= num_UCS; i++)
            {
                double[] UCSDoubles_current = new double[9];
                int      current_id         = 0;
                err = St7.St7GetUCSID(uID, i, ref current_id);
                err = St7.St7GetUCS(uID, current_id, ref UCSType, UCSDoubles_current);
                oM.Geometry.Point  origin = Geometry.Create.Point(UCSDoubles_current[0], UCSDoubles_current[1], UCSDoubles_current[2]);
                oM.Geometry.Vector x      = Geometry.Create.Point(UCSDoubles_current[3], UCSDoubles_current[4], UCSDoubles_current[5]) - origin;
                oM.Geometry.Vector y      = Geometry.Create.Point(UCSDoubles_current[6], UCSDoubles_current[7], UCSDoubles_current[8]) - origin;
                Cartesian          cs     = Geometry.Create.CartesianCoordinateSystem(origin, x, y);
                UCSs.Add(cs);
                if (!St7Error(err))
                {
                    return(new CoordSystems(false, new List <Cartesian>()));
                }
            }
            return(new CoordSystems(true, UCSs));
        }
Exemplo n.º 6
0
        /***************************************************/
        /**** Private methods                           ****/
        /***************************************************/

        private bool CreateObject(Node bhnode)
        {
            double[] XYZ = new double[3];

            // Geometry
            int uID    = 1;
            int err    = 0;
            int nodeId = GetAdapterId <int>(bhnode);

            XYZ[0] = bhnode.Position.X;
            XYZ[1] = bhnode.Position.Y;
            XYZ[2] = bhnode.Position.Z;
            err    = St7.St7SetNodeXYZ(1, nodeId, XYZ);
            if (!St7Error(err))
            {
                return(false);
            }

            oM.Geometry.Vector xVector    = bhnode.Orientation.X;
            oM.Geometry.Vector yVector    = bhnode.Orientation.Y;
            double[]           UCSDoubles = new double[] { 0, 0, 0, xVector.X, xVector.Y, xVector.Z, yVector.X, yVector.Y, yVector.Z };
            int UCSType = St7.csCartesian;


            int num_UCS = 0;
            int UCSid   = 0;

            err = St7.St7GetNumUCS(uID, ref num_UCS);
            if (!St7Error(err))
            {
                return(false);
            }

            bool ucsExists = false;

            for (int i = 1; i <= num_UCS; i++)
            {
                double[] UCSDoubles_current = new double[9];
                int      current_id         = 0;
                err = St7.St7GetUCSID(uID, i, ref current_id);
                err = St7.St7GetUCS(uID, current_id, ref UCSType, UCSDoubles_current);

                if (UCSDoubles_current.SequenceEqual(UCSDoubles))
                {
                    UCSid     = i;
                    ucsExists = true;
                    break;
                }
            }
            if (!ucsExists)
            {
                UCSid = num_UCS + 1;
                err   = St7.St7SetUCS(uID, UCSid, UCSType, UCSDoubles);
                err   = St7.St7SetUCSName(uID, UCSid, bhnode.Name);
            }


            // Restraints
            if (bhnode.Support == null)
            {
                return(true);
            }
            SetAdapterId(bhnode.Support, UCSid);
            int    freedomCase = 1;
            object freedomCaseObj;

            if (bhnode.CustomData.TryGetValue("Freedom", out freedomCaseObj))
            {
                freedomCase = (int)freedomCaseObj;
                while (St7.St7SetFreedomCaseType(uID, freedomCase, St7.fcNormalFreedom) != St7.ERR7_NoError) // there is no such freedom case, creating new
                {
                    err = St7.St7NewFreedomCase(uID, "fc " + freedomCase.ToString());
                    if (!St7Error(err))
                    {
                        return(false);
                    }
                }
            }
            int[] restraints = new int[6];
            restraints[0] = (bhnode.Support.TranslationX == oM.Structure.Constraints.DOFType.Fixed) ? St7.btTrue : St7.btFalse;
            restraints[1] = (bhnode.Support.TranslationY == oM.Structure.Constraints.DOFType.Fixed) ? St7.btTrue : St7.btFalse;
            restraints[2] = (bhnode.Support.TranslationZ == oM.Structure.Constraints.DOFType.Fixed) ? St7.btTrue : St7.btFalse;
            restraints[3] = (bhnode.Support.RotationX == oM.Structure.Constraints.DOFType.Fixed) ? St7.btTrue : St7.btFalse;
            restraints[4] = (bhnode.Support.RotationY == oM.Structure.Constraints.DOFType.Fixed) ? St7.btTrue : St7.btFalse;
            restraints[5] = (bhnode.Support.RotationZ == oM.Structure.Constraints.DOFType.Fixed) ? St7.btTrue : St7.btFalse;
            double[] enforcedDispls = Enumerable.Repeat(0.0, 6).ToArray();
            err = St7.St7SetNodeRestraint6(uID, nodeId, freedomCase, UCSid, restraints, enforcedDispls);
            if (!St7Error(err))
            {
                return(false);
            }

            // Stiffness Translational
            double[] translationalStiffness = new double[3];
            translationalStiffness[0] = bhnode.Support.TranslationalStiffnessX;
            translationalStiffness[1] = bhnode.Support.TranslationalStiffnessY;
            translationalStiffness[2] = bhnode.Support.TranslationalStiffnessZ;
            err = St7.St7SetNodeKTranslation3F(uID, nodeId, freedomCase, UCSid, translationalStiffness);
            if (!St7Error(err))
            {
                return(false);
            }

            // Stiffness Rotational
            double[] rotationalStiffness = new double[3];
            rotationalStiffness[0] = bhnode.Support.RotationalStiffnessX;
            rotationalStiffness[1] = bhnode.Support.RotationalStiffnessY;
            rotationalStiffness[2] = bhnode.Support.RotationalStiffnessZ;
            err = St7.St7SetNodeKRotation3F(uID, nodeId, freedomCase, UCSid, rotationalStiffness);
            if (!St7Error(err))
            {
                return(false);
            }
            return(true);
        }
Exemplo n.º 7
0
        /***************************************************/

        public static XYZ ToRevit(this oM.Geometry.Vector vector)
        {
            return(new XYZ(vector.X.FromSI(UnitType.UT_Length), vector.Y.FromSI(UnitType.UT_Length), vector.Z.FromSI(UnitType.UT_Length)));
        }
Exemplo n.º 8
0
        public static FreeFormProfile FreeFormProfile(IEnumerable <ICurve> edges, bool centreProfile = true)
        {
            IEnumerable <ICurve> result = edges.ToList();

            List <Point> cPoints = edges.SelectMany(x => x.IControlPoints()).ToList();

            // Any Point not on the XY-Plane
            if (cPoints.Any(x => Math.Abs(x.Z) > Tolerance.Distance))
            {
                // Is Planar
                Plane plane         = Geometry.Compute.FitPlane(cPoints);
                bool  failedProject = false;
                if (cPoints.Any(x => x.Distance(plane) > Tolerance.Distance))
                {
                    Reflection.Compute.RecordWarning("The Profiles curves are not Planar");
                    try
                    {
                        // Get biggest contributing curve and fit a plane to it
                        plane = Geometry.Compute.IJoin(edges.ToList()).OrderBy(x => Geometry.Query.Area(x)).Last().ControlPoints().FitPlane();

                        result = edges.Select(x => x.IProject(plane)).ToList();
                        Reflection.Compute.RecordWarning("The Profiles curves have been projected onto a plane fitted through the biggest curve's control points.");
                        cPoints = result.SelectMany(x => Geometry.Query.IControlPoints(x)).ToList();
                    }
                    catch
                    {
                        failedProject = true;
                    }
                }

                if (!failedProject)
                {
                    // Is Coplanar with XY
                    if (plane.Normal.IsParallel(oM.Geometry.Vector.ZAxis) == 0)
                    {
                        Reflection.Compute.RecordWarning("The Profiles curves are not coplanar with the XY-Plane. Automatic orientation has occured.");

                        plane.Normal = plane.Normal.Z > 0 ? plane.Normal : -plane.Normal;
                        double rad = plane.Normal.Angle(oM.Geometry.Vector.ZAxis);

                        Line axis = plane.PlaneIntersection(oM.Geometry.Plane.XY);
                        result  = result.Select(x => x.IRotate(axis.Start, axis.TangentAtParameter(0), rad)).ToList();
                        cPoints = result.SelectMany(x => Geometry.Query.IControlPoints(x)).ToList();
                    }

                    // Is on XY
                    if (cPoints.FirstOrDefault().Distance(oM.Geometry.Plane.XY) > Tolerance.Distance)
                    {
                        Reflection.Compute.RecordWarning("The Profiles curves are not on the XY-Plane. Automatic translation has occured.");
                        Point  p = cPoints.FirstOrDefault();
                        Vector v = new oM.Geometry.Vector()
                        {
                            X = p.X, Y = p.Y, Z = p.Z
                        };

                        result = result.Select(x => x.ITranslate(-v)).ToList();
                    }
                }
            }

            bool couldCentre = false;

            if (!result.Any(x => x.ISubParts().Any(y => y is NurbsCurve)))
            {
                // Join the curves
                List <PolyCurve> joinedCurves = Geometry.Compute.IJoin(result.ToList()).ToList();

                // Is Closed
                if (joinedCurves.Any(x => !x.IsClosed()))
                {
                    Reflection.Compute.RecordWarning("The Profiles curves does not form closed curves");
                }

                // Has non-zero area
                if (joinedCurves.Any(x => Geometry.Query.IArea(x) < Tolerance.Distance))
                {
                    Reflection.Compute.RecordWarning("One or more of the profile curves have close to zero area.");
                }

                if (!joinedCurves.Any(x => x.ISubParts().Any(y => y is Ellipse)))
                {
                    // Check curve curve Intersections
                    bool intersects = false;
                    for (int i = 0; i < joinedCurves.Count - 1; i++)
                    {
                        for (int j = i + 1; j < joinedCurves.Count; j++)
                        {
                            if (joinedCurves[i].CurveIntersections(joinedCurves[j]).Count > 0)
                            {
                                intersects = true;
                                break;
                            }
                        }
                        if (intersects)
                        {
                            break;
                        }
                    }
                    if (intersects)
                    {
                        Engine.Reflection.Compute.RecordWarning("The Profiles curves are intersecting eachother.");
                    }

                    if (centreProfile)
                    {
                        try
                        {
                            //Try centering the curves around the origin;
                            List <List <ICurve> > curves = result.ToList().IJoin().Cast <ICurve>().ToList().DistributeOutlines();
                            Point  centroid   = curves.Select(x => x[0]).Centroid(curves.SelectMany(x => x.Skip(1)));
                            Vector tranlation = Point.Origin - centroid;
                            result      = result.Select(x => x.ITranslate(tranlation)).ToList();
                            couldCentre = true;
                        }
                        catch (Exception e)
                        {
                        }
                    }
                }
                // Is SelfInteersecting
                if (joinedCurves.Any(x => Geometry.Query.IsSelfIntersecting(x)))
                {
                    Engine.Reflection.Compute.RecordWarning("One or more of the Profiles curves is intersecting itself.");
                }
            }

            if (centreProfile && !couldCentre)
            {
                Engine.Reflection.Compute.RecordWarning("Failed to align the centroid of the provided edgecurve with the global origin.");
            }

            return(new FreeFormProfile(result));
        }