Method for establishing parameterized corrugated board pool body based on Revit software

Abstract

The invention discloses a method for establishing a parameterized corrugated board pool body based on Revit software. The method comprises the steps that a corrugated board family is established in Revit; creating a horizontal square tube family in the Revit; creating a vertical square tube family in the Revit; creating a bottom plate family in the Revit; inputting size information and component parameters of the pool body into the Dynamo; calculating and determining the position and the size of each part of the pool body in the Dynamo; creating a self-defined node in the Dynamo, and generating a corrugated board instance; and the Dynamo script is operated, and a parameterized model is generated in the Revit. According to the method, through constraints of parameters and formulas, the sizes and the position relations among the components are kept consistent, errors caused by manual operation are avoided, and the integrity and the reliability of the model are improved; parameters such as the sectional area, the inertia moment and the turning radius of the square tube are calculated and given, basic data are provided for follow-up structural analysis and optimization, and design safety and economical efficiency can be improved.

Description

Technical Field

[0001] The invention relates to the technical field of building information modeling, and in particular to a method for establishing a parameterized corrugated board pool body based on Revit software. Background Art

[0002] In recent years, building information modeling (BIM) technology has been widely used in construction projects, gradually developing and penetrating into various fields. In environmental protection integrated equipment, BIM technology also plays an important role. It makes the design, construction and operation management of environmental protection equipment more efficient and intelligent, and provides strong support for the development of environmental protection. However, in the design process of corrugated board pool body, the traditional manual modeling method requires a lot of repeated calculations and is inefficient. This method not only consumes a lot of time and energy of designers, but also easily introduces human errors, resulting in insufficient model accuracy and unable to meet the accuracy requirements of prefabricated assembly construction.

[0003] The main problem in the existing technology is the lack of an effective method for parametric modeling of corrugated board pools, which makes the modeling process cumbersome and difficult to optimize and adjust in time. The manual modeling method cannot respond quickly to design changes, affecting work efficiency and project progress. In addition, there may be deviations between the model and the actual installation requirements and process parameters on site, affecting construction quality and equipment performance.

[0004] The consequences of these problems are significant. First, repeated calculations and modeling increase the design cycle and slow down project progress. Second, insufficient model accuracy may cause problems during construction, increasing the cost of rework and modification. Third, models that are difficult to quickly adjust and optimize limit the room for improvement of design solutions and may lead to poor equipment performance. Finally, manual modeling methods are difficult to meet the needs of modern engineering for efficient, accurate and intelligent design, affecting the competitiveness and innovation capabilities of enterprises.

[0005] In order to solve the above problems, the present invention provides a method for establishing a parametric corrugated board pool body. The method uses Autodesk Revit software and its visual programming tool Dynamo to realize the parametric layout of the corrugated board pool body, which can quickly perform three-dimensional modeling and timely optimize and adjust. By introducing parametric design, the workload of repeated calculations and repeated modeling is reduced, and the modeling efficiency and model accuracy are improved. The corrugated board pool body model established by the method meets the accuracy requirements of prefabricated assembly construction, meets the actual installation needs and process parameter requirements on site, and effectively improves the practicality and reliability of the BIM model. Summary of the invention

[0006] In order to overcome the shortcomings of the prior art, the present invention proposes a method for establishing a parametric corrugated board pool body based on Revit software. By creating a parametric family in Revit and automatically generating a model using a Dynamo script, the time and workload of manual modeling are greatly reduced, and the modeling efficiency is improved. Detailed parameters and formulas are defined in the method, such as the height and thickness of the corrugated board, the cross-sectional area, moment of inertia and gyration radius of the square tube, etc., to ensure the accuracy of the model size and structural characteristics. By utilizing parametric design, the size and component parameters of the pool body can be quickly adjusted according to needs, and models of different specifications can be generated to meet diverse design requirements.

[0007] To achieve the above object, the present invention provides a method for establishing a parametric corrugated board pool body based on Revit software, comprising the following steps: Step S1: Create a corrugated sheet family in Revit, set the height and thickness as variable parameters, calculate the parameter d based on the height and thickness, fix the length to 1450 mm, and set the width to a fixed value.

[0008] Step S2: Create a horizontal square tube family in Revit, set the height H, width W, depth D and length L as variable parameters, and calculate the parameters A, I and R through formulas and establish them using stretching and shearing operations.

[0009] Step S3: Create a vertical square tube family in Revit, set the height H, depth D and length L as variable parameters, and calculate the parameters I and R through the formula and establish them using the stretching operation.

[0010] Step S4: Create a base plate family in Revit, set the width and length as variable parameters, and use the stretching operation to create it.

[0011] Step S5: Input the size information and component parameters of the cell body in Dynamo, including the cell body width width, cell body length length, lower left corner coordinates p1, cell body center coordinates center, square tube height beamH, offset offset, bottom plate thickness thickness, corrugated board height wallH and corrugated board semi-thickness semi.

[0012] Step S6: Calculate and determine the position and size of each part of the pool body in Dynamo, including the starting point, end point, midpoint, length and rotation angle of the square tube and corrugated board, generate the center point list, length list and angle list of the square tube, which are used to create a square tube instance and set the corresponding parameters.

[0013] Step S7: Create a custom node in Dynamo for generating corrugated board, including methods of creation, cutting and mirroring, and generate a corrugated board instance by specifying parameters such as the starting point, end point, corrugated board height, corrugated board family type, cutting family type, corrugated board thickness and flip flag.

[0014] Step S8: Run the Dynamo script to generate a parametric corrugated plate pool model in Revit to achieve three-dimensional modeling and visualization of the pool.

[0015] Further, step S1 is specifically as follows: Step S11: Open the Revit software, select "New Family", and use the "Metric Generic Model" template; Step S12: Use the "Extrude" tool to draw the cross-sectional profile of the corrugated board in the family editor; Step S13: setting the length of the corrugated board to a fixed value of 1450 mm and the width to a fixed value; Step S14: Create parameters “height” (h) and “thickness” (t), and set them as variable parameters to allow users to adjust them in the project; Step S15: Define parameter "d", according to the formula Calculate, where k is a constant used to maintain the structural proportions of the corrugated board; Step S16: Apply parameter constraints in the family to associate the geometric dimensions of the corrugated board with the parameters "h", "t", and "d" to ensure that the shape of the corrugated board is updated when the parameters change.

[0016] Further, step S2 is specifically as follows: Step S21: Create a new family and select the "Metric General Model" template; Step S22: Use the "Stretch" tool to draw the cross-sectional profile of the horizontal square tube in a rectangular shape; Step S23: Create the following variable parameters: "height" H; "width" W; "depth" D; "length" L; Step S24: define the following parameters, which are calculated by the formula: Cross-sectional area A, calculated as A=W×H; The moment of inertia I is calculated as The radius of gyration R is calculated as follows: ; Step S25: Apply parameter constraints in the family to associate the geometric dimensions of the horizontal square tube with the parameters H, W, D, L, A, I, and R to ensure that the dimensions and cross-sectional properties can be adjusted according to the parameters; Step S26: Use the "Cut" function to add necessary bevels or chamfers to make the geometric shape of the horizontal square tube meet the design requirements.

[0017] Further, step S3 is specifically as follows: Step S31: Create a new family and select the "Metric General Model" template; Step S32: Use the "Stretch" tool to draw the cross-sectional profile of the vertical square tube in a rectangular shape; Step S33: Create the following variable parameters: "height" H; "depth" D; "length" L; Step S34: define the following parameters, which are calculated by the formula: The moment of inertia I is calculated as ; The radius of gyration R is calculated as follows: ; Step S35: Apply parameter constraints in the family to associate the geometric dimensions of the vertical square tube with the parameters H, D, L, I, and R to ensure that the dimensions and cross-sectional properties can be adjusted according to the parameters.

[0018] Further, step S4 is specifically as follows: Step S41: Create a new family and select the "Metric General Model" template; Step S42: Use the "Stretch" tool to draw the plane outline of the base plate in a rectangular shape; Step S43: creating variable parameters "width" and "length" for controlling the size of the base plate; Step S44: Apply parameter constraints in the family to associate the geometric dimensions of the base plate with the parameters "width" and "length" to ensure that the base plate size can be adjusted according to project requirements; Step S45: Ensure that the thickness of the base plate is a fixed value, or create a variable parameter "thickness" for adjustment as needed.

[0019] Further, step S5 is specifically as follows: Step S51: Start the Dynamo plug-in in Revit and create a new Dynamo script file; Step S52: In the Dynamo workspace, add a "Code Block" node; Step S53: Enter the following parameters in the code block to define the basic dimensions and component parameters of the pool: Pool width = 3000 mm; Pool length = 8000 mm; The lower left corner point p1 = Point.ByCoordinates(0, 0, 0) is used as the origin; Pool center center = Point.ByCoordinates(length / 2, width / 2, 0); Height and width of square tube beamH = 100 mm; offset = 10 mm; Base plate thickness = 8 mm; Corrugated board height wallH = 2800 mm; Corrugated board semi thickness semi = 23 mm; Step S54: Ensure that all parameters are correctly connected to subsequent nodes for calculation and component creation.

[0020] Further, step S6 is specifically as follows: Step S61: Calculate the starting point, end point and midpoint of the horizontal square tube A1: Starting point A1_s = p1.Translate(beamH / 2, 0, 0).

[0021] End point A1_e = A1_s.Translate(0, width, 0).

[0022] Midpoint A1_m = Point.ByCoordinates((A1_s.X + A1_e.X) / 2, (A1_s.Y + A1_e.Y) / 2, (A1_s.Z + A1_e.Z) / 2).

[0023] Calculate the length of the horizontal square tube A1 ylen = A1_s.DistanceTo(A1_e).

[0024] The start point B1_s, end point B1_e, midpoint B1_m and length xlen of the horizontal square tube B1 are calculated in a similar manner.

[0025] Generate a list of center points of the square tube, pts, including the midpoints of A1 and B1, and the corresponding midpoints of A2 and B2.

[0026] Generate a list of square tube lengths len = [ylen, xlen, ylen, xlen].

[0027] Generate a list of rotation angles of the square tube degrees = [0, 90, 180, 270] in degrees.

[0028] Calculate the positioning points of the vertical square tube: Point column_p1 = p1.Translate(offset + beamH / 2, offset + beamH / 2,thickness + beamH).

[0029] Point column_p2 = column_p1.Translate(0, width - 2 * offset - beamH, 0).

[0030] Point column_p3 = column_p2.Translate(length - 2 * offset - beamH, 0,0).

[0031] Point column_p4 = column_p1.Translate(length - 2 * offset - beamH, 0,0).

[0032] Create a point list for the vertical square tube column_pts = [column_p1, column_p2, column_p3,column_p4].

[0033] Calculate the start and end points of the corrugated board: The starting point of the west corrugated plate WA_s = p1.Translate(-beamH / 2 + semi, beamH / 2, 0).

[0034] The end point of the western corrugated board WA_e = WA_s.Translate(0, width - 2 * offset - 2 *beamH, 0).

[0035] The starting point of the north corrugated plate NB_s = p1.Translate(beamH / 2, -beamH / 2 + semi, 0).

[0036] The end point of the north corrugated board NB_e = NB_s.Translate(length - 2 * offset - 2 * beamH,0, 0).

[0037] Further, step S7 is specifically as follows: Step S71: Create a new custom node and name it CorrugatedBoardWall; Step S72: Add input port: start: the starting point of the corrugated board, type is Point; end: the end point of the corrugated board, type is Point; height: the height of the corrugated board, using the parameter wallH; boardType: Corrugated board family type, select the previously created corrugated board family; cutType: Cutting family type, select the hollow family created previously; boardThickness: corrugated board thickness, using parameter t; isFlip: flip flag, Boolean value, indicating whether the corrugated board needs to be mirrored; Step S73: Inside the custom node, use the Python script node or the Dynamo node to implement the following functions: Create a corrugated board instance, and generate a corrugated board with a height of height and a thickness of boardThickness between the specified start and end points; Cut the corrugated sheet to fit the tank structure, using the cutType family for Boolean operations; According to the isFlip parameter, decide whether to mirror the corrugated board; Step S74: Add the output port CorrugatedBoard to output the generated corrugated board instance.

[0038] Further, step S8 is specifically as follows: Step S81: Connect all nodes to ensure that parameters are correctly passed: Use the center point list pts, length list lens, and rotation angle list degrees of the square tube to create a horizontal square tube instance and set the corresponding parameters; At the calculated column_pts position, create a vertical square tube instance and set the height parameter to wallH; Calculate the center point of the floor floor_center = center.Translate(0, 0, beamH), create a floor instance, and set the length, width, and thickness parameters; Step S82: Use the custom node CorrugatedBoardWall to generate the corrugated board on the west side, with the input parameters of start = WA_s, end = WA_e, and other related parameters; Step S83: Using the plane with the X axis as the normal vector as the mirror plane, use the Mirror node to mirror the west side corrugated board to the east side to generate the east side corrugated board; Step S84: Similarly, generate the north side corrugated board, input parameters as start = NB_s, end = NB_e, and mirror to the south side to generate the south side corrugated board; Step S85: Check all node connections and parameter settings to ensure there are no errors; Step S86: Click the "Run" button on the Dynamo interface to execute the script; Step S87: Automatically generate a pool model including a bottom plate, square tubes and surrounding corrugated plates in Revit; Step S88: Inspect the generated model in Revit, verifying the following: Whether each component is in the correct position and whether the size meets the set parameters; Are the connections between components correct, with no overlaps or gaps? Whether the model is complete and meets the design requirements; Step S81: If necessary, adjust the parameters in the Dynamo script and rerun the script until the model meets expectations.

[0039] Compared with the prior art, the present invention has the following beneficial effects: 1. The present invention provides a method for establishing a parametric corrugated board pool body based on Revit software. By creating a parametric family in Revit and automatically generating a model using a Dynamo script, the time and workload of manual modeling are greatly reduced, and the modeling efficiency is improved. The method defines detailed parameters and formulas, such as the height and thickness of the corrugated board, the cross-sectional area, moment of inertia and gyration radius of the square tube, etc., to ensure the accuracy of the model size and structural characteristics. By using parametric design, the size and component parameters of the pool body can be quickly adjusted according to demand, and models of different specifications can be generated to meet diverse design requirements. 2. The present invention provides a method for establishing a parametric corrugated board pool body based on Revit software. Through the constraints of parameters and formulas, the size and position relationship between the components are kept consistent, avoiding errors caused by manual operation and improving the integrity and reliability of the model; calculating and assigning parameters such as the cross-sectional area, moment of inertia and gyration radius of the square tube, providing basic data for subsequent structural analysis and optimization, and helping to improve the safety and economy of the design.

[0040] 3. The present invention provides a method for establishing a parametric corrugated board pool body based on Revit software. The use of custom nodes makes the creation of components such as corrugated boards universal and repeatable, which is convenient for reuse in different projects and realizes the standardization and modularization of design; the model parameters are clear and the structure is clear, which facilitates communication and collaboration among team members and speeds up the project progress.

[0041] 4. The present invention provides a method for establishing a parametric corrugated board pool body based on Revit software. Through three-dimensional modeling and visual display, the design scheme is intuitively presented, which is convenient for discovering potential problems and improving the design quality. The parametric model makes subsequent modifications simple. Only the corresponding parameters need to be adjusted and the model can be automatically updated, reducing maintenance costs. BRIEF DESCRIPTION OF THE DRAWINGS

[0042] In order to more clearly illustrate the specific implementation methods of the present invention or the technical solutions in the prior art, the drawings required for use in the specific implementation methods or the description of the prior art will be briefly introduced below. Obviously, the drawings described below are some implementation methods of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying creative work.

[0043] Figure 1 It is a schematic diagram of the steps of the present invention Figure 2 It is a 3D model of corrugated board Figure 3 Schematic diagram of the plane dimensions of corrugated board Figure 4 Schematic diagram of corrugated board properties Figure 5 It is a schematic diagram of the plane dimensions of a horizontal square tube; Figure 6 This is a schematic diagram of the 3D model of a horizontal square tube. Figure 7 Schematic diagram of horizontal square tube parameters Figure 8 This is a schematic diagram of the plane dimensions of a vertical square tube Fig. 9 This is a schematic diagram of a vertical square tube 3D model. Fig.10 It is a schematic diagram of vertical square tube parameters Figure 11-12 This is a schematic diagram of the base plate Fig.13 This is a schematic diagram of the base plate parameters Fig.14 This is a schematic diagram of the plane size of the hollow family Fig.15 This is a schematic diagram of the hollow family 3D model Fig.16 This is a schematic diagram of hollow family parameters Fig.17 It is a schematic diagram of size information Fig.18 This is a schematic diagram of the square tube position Fig.19 Create a horizontal square tube diagram Fig. 20 Create a base plate diagram Fig.21 Create a vertical square tube diagram Fig. 22 This is the schematic diagram of the starting and ending points of the corrugated board Fig.23 This is a schematic diagram of a custom node for corrugated board. Fig.24 Add a reference diagram Figure 25-26 It is a code diagram that defines corrugated board class 1 Fig. 27 Create a schematic diagram of a corrugated board wall Fig.28 Create a schematic diagram of a corrugated board wall Fig.29 This is a schematic diagram of the operation results DETAILED DESCRIPTION

[0044] The technical solution of the present invention will be more clearly and completely explained below through description of preferred embodiments of the present invention in combination with the accompanying drawings.

[0045] like Figure 1 As shown, the present invention is specifically: Step S1: Create a corrugated board family in Revit, set the height and thickness as variable parameters, the variable parameters are calculated based on the height and thickness, the length is fixed to 1450 mm, and the width is set to a fixed value; Step S2: Create a horizontal square tube family in Revit, set the height H, width W, depth D and length L as variable parameters, and calculate the cross-sectional area A, moment of inertia I and radius of gyration R through formulas, and establish them using stretching and shearing operations.

[0046] Step S3: Create a vertical square tube family in Revit, set the height H, depth D and length L as variable parameters, and calculate the parameters I and R through the formula and establish them by stretching operation; Step S4: Create a base plate family in Revit, set the width and length as variable parameters, and use the stretching operation to create it; Step S5: Input the size information and component parameters of the cell body in Dynamo, including the cell body width width, cell body length length, lower left corner coordinates p1, cell body center coordinates center, square tube height beamH, offset offset, bottom plate thickness thickness, corrugated board height wallH and corrugated board semi-thickness semi; Step S6: Calculate and determine the position and size of each part of the pool body in Dynamo, including the starting point, end point, midpoint, length and rotation angle of the square tube and corrugated board, generate the center point list, length list and angle list of the square tube, which are used to create a square tube instance and set the corresponding parameters; Step S7: creating a custom node in Dynamo for generating corrugated board, including methods of creation, cutting and mirroring, and generating a corrugated board instance through specified parameters; Step S8: Run the Dynamo script to generate a parametric corrugated plate pool model in Revit to achieve three-dimensional modeling and visualization of the pool.

[0047] As a specific implementation method, the following production process is included: Step 1: Based on the corrugated board size data, a corrugated board family is established by stretching, where the height and thickness are two variable parameters, the d parameter is given to the formula, and the other dimensions are fixed. The fixed length of the corrugated board is 1450; Figure 2-4 As shown; Step 2: Based on the square tube size data, a horizontal square tube family is established by stretching and shearing, where the four parameters H, W, d, and L are variable, and the parameters A, I, and R are given to the formula; Figure 5-7 As shown; Step 3: Based on the square tube size data, a vertical square tube family is established by stretching, where the three parameters H, d, and L are variable, and the I and R parameters are given a formula; Figure 8-10 As shown; Step 4: Create a base plate family by stretching, where the width and length are two variable parameters; Figure 11-13 As shown; Step 5: Create a hollow family by stretching, where the width, length, and height are three variable parameters; Figure 14-16 As shown; Step 6: Create a new Dynamo file, double-click the blank area and enter the size information code in CodeBlock, including the pool width width=3000, pool length=8000, lower left corner point p1=Point.Origin(), pool center center=Geometry.Translate(p1,len / 2,width / 2,0), square tube height and width beamH=100, offset offset=10, thickness thickness = 8, corrugated board height wallH=2800, corrugated board semi-thickness semi=23; Fig.17 As shown; Step 7: Double-click the blank area to enter the relevant code for the square tube position in CodeBlock, including the starting point, end point, midpoint, and length of the A1 square tube: A1_s = p1.Add(Vector.ByCoordinates(beamH / 2,0,0)), A1_e = A1_s.Add(Vector.ByCoordinates(0,width,0)), A1_m = Point.ByCoordinates((A1_s.X+A1_e.X) / 2,(A1_s.Y+A1_e.Y) / 2,(A1_s.Z+A1_e.Z) / 2), ylen = A1_s.DistanceTo(A1_e), the starting point, end point, midpoint, and length of the B1 square tube: B1_s = A1_e.Add(Vector.ByCoordinates(-beamH / 2,-beamH / 2,0)), B1_e = B1_s.Add(Vector.ByCoordinates(len,0,0)), B1_m = Point.ByCoordinates((B1_s.X+B1_e.X) / 2,(B1_s.Y+B1_e.Y) / 2,(B1_s.Z+B1_e.Z) / 2), xlen = B1_s.DistanceTo(B1_e), square tube center point list: [A1_m,B1_m,A2_m,B2_m], square tube length list: [ylen,xlen,ylen,xlen], square tube angle list: [0,90,180,270], where p1, beamH, width, and len are connected to the ports with the same name in step 6; Fig.18 As shown; Step 8: Create a Family Types node and select "Square Tube_Horizontal". Double-click the blank area and enter the relevant code for creating a horizontal square tube in the CodeBlock: cubes1 = FamilyInstance.ByPoint(type,pts), cubes2 = Elements.Element.SetParameterByName(cubes1, "L", lens), cubes3 = FamilyInstance.SetRotation(cubes2, degrees), where type is connected to the node that selects "Square Tube_Horizontal", and pts, lens, and degrees are connected to the ports with the same name in step 7; Fig.19 Shown Step 9: Create a Family Types node and select "Floor" from it. Double-click the blank area and enter the relevant code to create the floor in CodeBlock. Floor center: floor_center=Geometry.Translate(center,0,0,beamH), floor parameter list: para_nums = [len-2*offset,width-2*offset,thickness], floor parameter name: para_names = ["length", "width", "thickness"], create floor: floor1 = FamilyInstance.ByPoint(type, floor_center), floor2 = Elements.Element.SetParameterByName(floor1, para_names, para_nums); Fig. 20 As shown; Step 10: Create a Family Types node and select "Square Tube_Vertical" from it. Double-click the blank area and enter the relevant code for creating a vertical square tube in CodeBlock. Vertical square tube positioning point: column_p1=Geometry.Translate(p1,offset+beamH / 2,offset+beamH / 2,thickness+beamH), column_p2=Geometry.Translate(column_p1,0,width-2*offset-beamH,0), column_p3=Geometry.Translate(column_p2,len-2*offset-beamH,0,0), column_p4=Geometry.Translate(column_p1,len-2*offset-beamH,0,0), column_pts=[column_p1,column_p2,column_p3,column_p4], columns1 = FamilyInstance.ByPoint(type,column_pts), columns2 = Elements.Element.SetParameterByName(columns1, "H",wallH); such as Fig.21 Shown Step 11: Double-click the blank area to enter the relevant codes for the starting and ending points of the corrugated board in CodeBlock. The starting and ending points of the west corrugated board: A1_s=Geometry.Translate(p1,-beamH / 2+semi,beamH / 2,0), A1_e =Geometry.Translate(A1_s,0,width-2*offset-2*beamH,0), the starting and ending points of the north corrugated board: B1_s=Geometry.Translate(p2,beamH / 2,beamH / 2-semi,0), B1_e = Geometry.Translate(B1_s,len-2*offset-2*beamH,0,0); Fig. 22 Shown Step 12: Create a custom node CorrugatedBoardWall.dyf, create a python node, add ports IN[0] ~ IN[6], create an Input node, input start, end, height, boardType, cutType, boardThickness, isFlip respectively, and connect them to ports IN[0] ~ IN[6] in sequence, add an Output node, and input CorrugatedBoardWall. Open the python node, add the corresponding reference, and define the CorrugatedBoardWall class and its methods CreateBoards(self), CutBoard(self), Mirror(self, plane), add the following code: start = IN[0], end = IN[1], height = IN[2], eleType = IN[3], cutType = IN[4], thickness = IN[5], isFlip = IN[6], wall = CorrugatedBoardWall(start, end, height, eleType, cutType, thickness, isFlip), out = wall; Figure 23-Figure 26 As shown; Step 13: Create the west wall and the east wall, create a CorrugatedBoardWall node, connect the start and end ports to A1_s and A1_e in step 11 respectively; create a Family Types node and select "Corrugated Board" from it, create a Family Types node and select "object_Hollow Cube" from it, and connect them to boardType and cutType respectively, and connect the remaining ports to the ports with the same names in step 6, create a Vector.XAxis node, a Plane.ByOriginNormal node, and a CorrugatedBoardWall.Mirror node, and connect the ports as shown below Fig. 27 As shown; Step 14: Create the north and south walls, and create a CorrugatedBoardWall node, where the start and end ports are connected to B1_s and B1_e in step 11 respectively; include the "Corrugated Board" Family Types node, include the "object_Hollow Cube" Family Types node, which are connected to boardType and cutType respectively, and the remaining ports are connected to the ports with the same names in step 6. Create a Vector.YAxis node, a Plane.ByOriginNormal node, and a CorrugatedBoardWall.Mirror node, and connect the ports as shown below. Fig.28 As shown; Step 15: Run the Dynamo program to generate the model, such as Fig.29 ; As a specific embodiment, first, in Revit software, create a corrugated board family. Open Revit, select "New Family", and use the "Metric General Model" template. Use the extrusion tool to draw the cross-sectional profile of the corrugated board, with the length fixed at 1450 mm and the width fixed at 600 mm. Create variable parameters "height" (h) and "thickness" (t), with initial values ​​of 2800 mm and 8 mm, respectively. Define parameter d, using the formula d = (h×t) / 350, where the constant k = 350. Associate the geometric dimensions of the corrugated board with the parameters h, t, and d to ensure the parameterization of the model.

[0048] Next, create a horizontal square tube family. Create a new family and use the "Metric General Model" template. Use the extrude tool to draw the cross section of the square tube. The initial height H is 100 mm, the width W is 100 mm, and the depth D is 5 mm. Create variable parameters H, W, D, and L (length). The initial length L is 3000 mm. Define the cross-sectional area A=(W−2D)×(H−2D), the moment of inertia , radius of gyration . Associate geometric dimensions with parameters H, W, D, L to ensure parametric modeling.

[0049] Then, create a vertical square tube family. Create a new family and use the "Metric Generic Model" template. Use the Extrude tool to draw a cross section with an initial height H of 2800 mm, a width W of 100 mm, a depth D of 5 mm, and a length L of 100 mm. Define the moment of inertia I and the radius of gyration R, similar to the horizontal square tube family. Associate the geometric dimensions with the parameters H, D, and L.

[0050] After that, create a base plate family. Create a new family and use the "Metric Generic Model" template. Use the Extrude tool to draw a rectangle with an initial width of 2980 mm, a length of 7980 mm, and a thickness of 8 mm. Create variable parameters "Width" and "Length" to associate the geometric dimensions with the parameters.

[0051] Next, open the Revit project, start Dynamo, and create a new file. In Dynamo, add a code block node and enter the size information and component parameters of the pool: width = 3000 mm, length = 8000 mm, lower left corner p1 = (0, 0, 0), center of the pool = (length / 2, width / 2, 0), square tube height beamH = 100 mm, offset offset = 10 mm, bottom plate thickness thickness = 8 mm, corrugated board height wallH = 2800 mm, corrugated board semi thickness semi = 23 mm.

[0052] In Dynamo, calculate and determine the position and size of each part of the pool. Calculate the starting point A1_s = p1 translation (beamH / 2, 0, 0) of the horizontal square tube A1, the end point A1_e = A1_s translation (0, width, 0), the midpoint A1_m is the midpoint between the starting point and the end point, and the length ylen is the distance from A1_s to A1_e. Calculate the position and length of other square tubes in a similar way, and generate the center point list pts, length list lens, and angle list degrees of the square tube.

[0053] Calculate the positioning point of the vertical square tube: column_p1 = p1 translation (offset + beamH / 2, offset+ beamH / 2, thickness + beamH), calculate column_p2, column_p3, column_p4 in turn, and get the positions of the four vertical square tubes.

[0054] Calculate the starting and ending points of the corrugated plate. The starting point of the western corrugated plate WA_s = p1 translation (-beamH / 2 +semi, beamH / 2, 0), and the ending point WA_e = WA_s translation (0, width - 2 × offset - 2 × beamH, 0). The starting point of the northern corrugated plate NB_s = p1 translation (beamH / 2, -beamH / 2 + semi, 0), and the ending point NB_e = NB_s translation (length - 2 × offset - 2 × beamH, 0, 0).

[0055] Create a custom node CorrugatedBoardWall, add input ports start, end, height, boardType, cutType, boardThickness, isFlip, and output the corrugated board instance. Inside the node, implement the functions of creating corrugated board, cutting, and mirroring.

[0056] In Dynamo, use the Family Types node to select the "horizontal square tube family", use FamilyInstance.ByPoint to create a horizontal square tube instance at the point in the pts list, set the length lens and the rotation angle degrees. Select the "vertical square tube family", create a vertical square tube instance at the point in the column_pts list, set the height to wallH. Select the "bottom plate family", create a bottom plate instance at floor_center = center and translate (0, 0, beamH), set the width, length and thickness.

[0057] Call the custom node CorrugatedBoardWall, input the parameters of the corrugated board on the west side, and generate a corrugated board instance. Use the Mirror node to mirror the corrugated board on the west side to the east side. Generate the corrugated boards on the north and south sides in a similar way.

[0058] Run the Dynamo script to generate a complete pool model in Revit. Check the model to ensure that the components are positioned correctly, the dimensions meet the set parameters, and the components are connected correctly without overlap or gaps. If you need to adjust the model size, just modify the corresponding parameters in Dynamo and rerun the script, and the model will automatically update.

[0059] The above specific implementations are only descriptions of the preferred implementations of the present invention, and do not limit the protection scope of the present invention. Without departing from the design concept and spirit of the present invention, various modifications, substitutions and improvements made by ordinary technicians in this field to the technical solution of the present invention based on the text description and drawings provided by the present invention should all fall within the protection scope of the present invention. The protection scope of the present invention is determined by the claims.

Claims

1. A method for establishing a parametric corrugated board pool body based on Revit software, characterized in that: The following steps are involved: Step S1: Create a corrugated board family in Revit, set the height and thickness as variable parameters, the variable parameters are calculated based on the height and thickness, the length is fixed to 1450 mm, and the width is set to a fixed value; Step S2: Create a horizontal square tube family in Revit, set the height H, width W, depth D and length L as variable parameters, and calculate the cross-sectional area A, moment of inertia I and radius of gyration R through formulas, and establish them by stretching and shearing operations; Step S3: Create a vertical square tube family in Revit, set the height H, depth D and length L as variable parameters, and calculate the parameters I and R through the formula and establish them by stretching operation; Step S4: Create a base plate family in Revit, set the width and length as variable parameters, and use the stretching operation to create it; Step S5: Input the size information and component parameters of the cell body in Dynamo, including the cell body width width, cell body length length, lower left corner coordinates p1, cell body center coordinates center, square tube height beamH, offset offset, bottom plate thickness thickness, corrugated board height wallH and corrugated board semi-thickness semi; Step S6: Calculate and determine the position and size of each part of the pool body in Dynamo, including the starting point, end point, midpoint, length and rotation angle of the square tube and corrugated board, generate the center point list, length list and angle list of the square tube, which are used to create a square tube instance and set the corresponding parameters; Step S7: creating a custom node in Dynamo for generating corrugated board, including methods of creation, cutting and mirroring, and generating a corrugated board instance through specified parameters; Step S8: Run the Dynamo script to generate a parametric corrugated plate pool model in Revit to achieve three-dimensional modeling and visualization of the pool.

2. A method for establishing a parametric corrugated board pool body based on Revit software according to claim 1, characterized in that: Step S1 is specifically as follows: Step S11: Open the Revit software, select "New Family", and use the "Metric Generic Model" template; Step S12: Use the "Extrude" tool to draw the cross-sectional profile of the corrugated board in the family editor; Step S13: setting the length of the corrugated board to a fixed value of 1450 mm and the width to a fixed value; Step S14: Create parameters "height" (h) and "thickness" (t) and set them as variable parameters, allowing users to adjust them in the project; Step S15: Define parameter "d", according to the formula Calculate, where k is a constant used to maintain the structural proportions of the corrugated board; Step S16: Apply parametric constraints in the family to associate the geometric dimensions of the corrugated board with the parameters "h", "t", and "d" to ensure that the shape of the corrugated board is updated when the parameters change.

3. The method for establishing a parametric corrugated board pool body based on Revit software according to claim 1, characterized in that: Step S2 is specifically as follows: Step S21: Create a new family and select the "Metric General Model" template; Step S22: Use the "Extrude" tool to draw the cross-sectional profile of the horizontal square tube in a rectangular shape; Step S23: Create the following variable parameters: "Height" H; "width" W; "depth" D; "length" L; Step S24: define the following parameters, which are calculated by the formula: Cross-sectional area A, calculated as A=W×H; The moment of inertia I is calculated as ; The radius of gyration R is calculated as follows: ; Step S25: Apply parameter constraints in the family to associate the geometric dimensions of the horizontal square tube with the parameters H, W, D, L, A, I, and R to ensure that the dimensions and cross-sectional properties can be adjusted according to the parameters; Step S26: Use the "Cut" function to add bevels or chamfers to make the geometric shape of the horizontal square tube meet the design requirements.

4. The method for establishing a parametric corrugated board pool body based on Revit software according to claim 1, characterized in that: Step S3 is as follows: Step S31: Create a new family and select the "Metric General Model" template; Step S32: Use the "Stretch" tool to draw the cross-sectional profile of the vertical square tube in a rectangular shape; Step S33: Create the following variable parameters: "Height" H; "depth" D; "length" L; Step S34: define the following parameters, which are calculated by the formula: The moment of inertia I is calculated as ; The radius of gyration R is calculated as follows: ; Step S35: Apply parameter constraints in the family to associate the geometric dimensions of the vertical square tube with the parameters H, D, L, I, and R to ensure that the dimensions and cross-sectional properties can be adjusted according to the parameters.

5. The method for establishing a parametric corrugated board pool body based on Revit software according to claim 1, characterized in that: Step S4 is specifically as follows: Step S41: Create a new family and select the "Metric General Model" template; Step S42: Use the "Stretch" tool to draw the plane outline of the base plate in a rectangular shape; Step S43: creating variable parameters "width" and "length" to control the size of the base plate; Step S44: Apply parameter constraints in the family to associate the geometric dimensions of the base plate with the parameters "width" and "length" to ensure that the base plate size can be adjusted according to project requirements; Step S45: Ensure that the thickness of the base plate is a fixed value, or create a variable parameter "thickness" for adjustment as needed.

6. The method for establishing a parametric corrugated board pool body based on Revit software according to claim 1, characterized in that: Step S5 is specifically as follows: Step S51: Start the Dynamo plug-in in Revit and create a new Dynamo script file; Step S52: Add a "Code Block" node in the Dynamo workspace; Step S53: Enter the following parameters in the code block to define the basic dimensions and component parameters of the cell body; Step S54: Ensure that all parameters are correctly connected to subsequent nodes for calculation and component creation.

7. The method for establishing a parametric corrugated board pool body based on Revit software according to claim 1, characterized in that: Step S6 is specifically as follows: Step S61: Calculate the starting point, end point, midpoint and length of the horizontal square tubes A1 and B1; Step S62: Generate a list of center points, a list of lengths, and a list of rotation angles of the square tube, in degrees; Step S63: Calculate the positioning points of the vertical square tube and create a point list of the vertical square tube; Step S64: Calculate the starting point and the end point of the corrugated board.

8. The method for establishing a parametric corrugated board pool body based on Revit software according to claim 1, characterized in that: Step S7 is specifically as follows: Step S71: create a new custom node; Step S72: adding an input port; Step S73: Inside the custom node, use the Python script node or the Dynamo node to implement the following functions: Create a corrugated board instance and generate the corrugated board between the specified start and end points; Cut the corrugated sheet to fit the tank structure, using the cutType family for Boolean operations; According to the parameters, decide whether to mirror the corrugated board; Step S74: Add an output port to output the generated corrugated board instance.

9. The method for establishing a parametric corrugated board pool body based on Revit software according to claim 1, characterized in that: Step S8 is specifically as follows: Step S81: Connect all nodes to ensure that parameters are correctly passed: Use the center point list, length list and rotation angle list of the square tube to create a horizontal square tube instance and set the corresponding parameters; At the location of the calculated center point list, create a vertical square tube instance and set the height parameter to wallH; Calculate the center point of the base plate, create a base plate instance, and set the length, width, and thickness parameters; Step S82: Use the custom node to generate the west side corrugated board and input parameters; Step S83: Using the plane with the X axis as the normal vector as the mirror plane, use the Mirror node to mirror the west side corrugated board to the east side to generate the east side corrugated board; Step S84: Similarly, generate the north side corrugated board, input parameters, and mirror it to the south side to generate the south side corrugated board; Step S85: Check all node connections and parameter settings to ensure there are no errors; Step S86: Click the "Run" button on the Dynamo interface to execute the script; Step S87: Automatically generate a pool model including a bottom plate, square tubes and surrounding corrugated plates in Revit; Step S88: Inspect the generated model in Revit, verifying the following: Whether each component is in the correct position and whether the size meets the set parameters; Are the connections between components correct, with no overlaps or gaps? Whether the model is complete and meets the design requirements; Step S81: If necessary, adjust the parameters in the Dynamo script and rerun the script until the model meets expectations.

Images