Railway station structure engineering demand parameter matrix rapid construction method and system

Abstract

The application discloses a kind of railway station structure engineering demand parameter matrix fast construction method and system, based on the Application Programming Interface (Application Programming Interface, API) opened by MIDAS Gen design software, through Python programming language, automatically create and set the time load function of railway station structure model, time load working condition, ground acceleration, then batch execution elastoplastic time history analysis, extract the rotation angle of key component inelastic hinge and floor interlayer acceleration, finally automatically assemble and form engineering demand parameter (Engineering Demand Parameter, EDP) matrix, significantly improve the convenience and feasibility of railway station seismic resilience evaluation.

Description

Technical Field

[0001] This invention relates to the field of railway engineering technology, specifically to a method and system for rapidly constructing a structural engineering requirement parameter matrix for railway passenger stations. Background Technology

[0002] As core hubs of urban transportation networks, railway passenger stations undertake vital functions such as passenger transport, cargo distribution, and train dispatching, playing a particularly crucial role in emergency scenarios such as earthquake relief. Historical earthquake damage cases show that damage to railway passenger stations often induces prolonged service interruptions, leading to significant economic losses and widespread social impacts. Therefore, minimizing post-earthquake functional disruptions, promoting the rapid restoration of railway passenger station functions, and enhancing the overall structural seismic resilience are of paramount importance to ensuring the safe operation of railway hubs.

[0003] According to relevant building seismic toughness evaluation standards, the prerequisite for determining the damage state of structural components is to construct an engineering requirement parameter matrix for the entire structure. Commonly used component engineering requirement parameters include: component rotation angle θ, inter-story acceleration FPA, etc. Elastoplastic time-history analysis is performed on the structure under different seismic motions to obtain the engineering requirement parameters for each time-history analysis, which are then assembled into a matrix. Based on the component's engineering requirement parameter matrix and vulnerability data, the damage state is ultimately determined.

[0004] However, constructing the engineering requirement parameter matrix requires repeated elastoplastic time-history analyses dozens or even hundreds of times. Each analysis necessitates setting time-history load cases, time-history load functions, ground acceleration, and other parameters. After each analysis, the rotation angles and other requirement parameters of hundreds or even thousands of components must be statistically analyzed and compiled to assemble the parameter matrix. Therefore, the workload of calculation, analysis, and data processing is enormous. Traditional manual methods are not only time-consuming and labor-intensive but also prone to data errors. In recent years, some scholars have developed batch calculation and data processing methods based on various programming languages, but most of these methods rely on finite element analysis software with parametric programming capabilities (such as OpenSees). There is still a lack of methods for rapidly constructing engineering requirement parameter matrices using specialized design software (such as MIDAS). Summary of the Invention

[0005] This invention provides a method and system for rapidly constructing a structural engineering requirement parameter matrix for railway passenger stations, in order to solve the problem that there is a lack of methods for rapidly constructing engineering requirement parameter matrices based on professional design software (such as MIDAS) in the existing technology.

[0006] According to the first aspect, one embodiment provides a method for rapidly constructing a structural engineering requirement parameter matrix for railway passenger stations, the method comprising:

[0007] Create or import a railway passenger station structure model into MIDAS Gen software and create floor groups;

[0008] Create a MIDAS API call function on the Python platform;

[0009] In the Python environment, a time-history load function request is constructed, and the function is called using the MIDAS API. The time-history load function request is sent to the MidasGen software via a POST request, which automatically completes the creation of the time-history load function.

[0010] In the Python environment, a time-history load case request is constructed, and the MIDAS API is used to call functions to send the time-history load case request to the MidasGen software via POST request, which automatically completes the creation of the time-history load case.

[0011] In the Python environment, a ground acceleration request is constructed, and then the MIDAS API is used to call functions to send the ground acceleration request to the MidasGen software in the form of a POST request, which automatically completes the creation of the ground acceleration.

[0012] In the Python environment, the MIDAS API is first used to call functions to send a file save request to the MidasGen software via POST request to save the calculation file. Then, the calculation analysis request is sent to the Midas Gen software via POST request to execute the calculations for all time history analysis conditions.

[0013] In the Python environment, a non-elastic hinge request for the component is created. The MIDAS API is used to call functions to send the non-elastic hinge request to the MidasGen software via POST request, and the calculation results of all non-elastic hinges are automatically obtained. The structure is then iterated through each floor, and acceleration requests for all nodes on each floor are created. The MIDAS API is used to call functions to send the acceleration requests for all nodes on each floor via POST request, and the calculation results of the acceleration of the corresponding node on each floor are automatically obtained.

[0014] Based on the calculation results of inelastic hinges and the acceleration of each floor node, the rotation angle and floor acceleration of key components under each time-history load condition are extracted and assembled into an engineering requirement parameter matrix.

[0015] Furthermore, a railway passenger station structure model is created or imported into the MIDAS Gen software, and floor groups are created, specifically including:

[0016] In MIDAS Gen software, create or import the railway passenger station structure model to be analyzed, and set the inelastic hinge characteristic values ​​of beams, columns, and supports respectively, and assign the inelastic hinge characteristic values ​​to the corresponding components.

[0017] Based on the model floor information in the MIDAS Gen software, create floor groups in the structure group and assign the nodes and units of the corresponding floors to the corresponding floor groups.

[0018] Furthermore, the MIDAS API call functions are created in the Python platform, specifically including:

[0019] Create a function to call the MIDAS API in the Python platform. Based on the server address URL and access authentication key MAPIKey, use the Requests library to send an HTTP request and perform corresponding operations based on different HTTP request headers and request body content. HTTP requests include POST (Create Resource), PUT (Update Resource), GET (Get Resource), and DELETE (Delete Resource).

[0020] Furthermore, in the Python environment, a time-history load function request is constructed, and the MIDAS API is used to call the function. The time-history load function request is sent to the MidasGen software via a POST request, automatically completing the creation of the time-history load function. Specifically, this includes:

[0021] In a Python environment, automatically read seismic wave data from a specified directory and extract time series values ​​t line by line. i and acceleration sequence value a i And combine them into a dictionary Fun_Dic;

[0022] Construct the TimeFunc_json body of the time-scheduled load function request, including:

[0023] Set the time history load function name, select the time history load function type, and set the time function data type to dimensionless acceleration;

[0024] Determine the ground motion modulation coefficient and gravitational acceleration;

[0025] Assign values ​​from the seismic wave data dictionary Fun_Dic to the function data.

[0026] Furthermore, in the Python environment, a time-history load case request is constructed, and the MIDAS API function is used to send the time-history load case request to the MidasGen software via a POST request, automatically completing the creation of the time-history load cases, specifically including:

[0027] In the Python environment, input the natural period T1 and damping ratio ξ1 of the first vibration mode of the structure, and the natural period T2 and damping ratio ξ2 of the second vibration mode, and the system will automatically read the seismic wave data from the specified directory and extract the duration, time step and total time step of each seismic wave in a loop.

[0028] Construct the Time_Case_json body of the time-history load case request, including:

[0029] Set the load case name, select nonlinear time history dynamic analysis as the analysis type, select direct integration method as the analysis method, select transient time history type, and set the analysis time to the duration t0 of the seismic wave, the analysis time step to the time step Δt, and the output time step to the total time step n. t ;

[0030] Choose the loading sequence method, use static load as the successor to the previous load case, and choose not to consider geometric nonlinearity.

[0031] Select the damping calculation method for mass and stiffness factors, where the mass and stiffness factors are obtained through model damping calculation, and the natural period T1 and damping ratio ξ1 of the first mode and the natural period T2 and damping ratio ξ2 of the second mode are respectively input.

[0032] The Newmark method was chosen as the direct integration method for the numerical integration of the dynamic equations.

[0033] Set the minimum iteration step size and maximum number of iterations for the nonlinear analysis, select the displacement convergence criterion and the force convergence criterion respectively, and set the convergence value; further select the Fehlberg-based Runge-Kutta method as the boundary nonlinear analysis method, and set the allowable error.

[0034] Furthermore, in the Python environment, a ground acceleration request is constructed, and then the MIDAS API call function is used to send the ground acceleration request to the MidasGen software via a POST request, automatically completing the creation of the ground acceleration, specifically including:

[0035] In the Python environment, the ground acceleration direction Dir and ground acceleration angle Ang are determined. The created MIDAS API call function is used to obtain all time-history load functions and time-history load cases currently created in the Midas Gen software by using a GET request. The name of each time-history load function Time_Func_Name(i) and the name of each time-history load case Time_Case_Name(i) are obtained by looping through them.

[0036] Further determine the direction of ground acceleration, Dir, and create a ground acceleration request body, Ground_Acce_json, including:

[0037] Set the time-history load case name to Time_Case_Name(i);

[0038] Based on the direction of ground acceleration Dir, set the time history load function in the corresponding direction to Time_Func_Name(i), and set the adjustment coefficient of ground acceleration and the time when it begins to act on the structure;

[0039] Set the angle of the horizontal ground acceleration to Ang.

[0040] Furthermore, in the Python environment, a non-elastic hinge request for the component is created. Using the MIDAS API, a function is called to send the non-elastic hinge request to the MidasGen software via a POST request, automatically retrieving the calculation results for all non-elastic hinges, specifically including:

[0041] In the Python environment, the created MIDAS API call function is used to obtain all time-history load cases currently created in the MidasGen software via GET request, and the name of each load case, Time_Case_Name(i), is obtained by looping through it.

[0042] Further determine the direction of ground acceleration, Dir, and create a component inelastic hinge request body, Inelastic_Hinge_json, including:

[0043] Select the inelastic hinge type as concentrated inelastic hinge;

[0044] Set the data export path, data unit, and data format. The exported data includes the unit number and the corresponding rotation angle.

[0045] Select the corresponding time-history load case as Time_Case_Name(i).

[0046] Furthermore, the system iterates through each floor of the structure, creating acceleration requests for all nodes on each floor. Then, using the MIDAS API, it sends these acceleration requests to the Midas Gen software via a POST request, automatically retrieving the acceleration calculation results for each floor's corresponding nodes. Specifically, this includes:

[0047] Create the Node_Acce_json header for all nodes on each floor, including:

[0048] Select absolute acceleration as the nodal acceleration type;

[0049] Set the data export path, data unit, and data format. The data export content includes node number, time history load type, and acceleration direction.

[0050] Obtain node numbers layer by layer by creating floor groups;

[0051] Select the corresponding time-history load case as Time_Case_Name(i).

[0052] Furthermore, based on the calculation results of inelastic hinges and the acceleration of each floor node, the rotation angle and floor acceleration of key components under each time-history load case are extracted and assembled into an engineering requirement parameter matrix, specifically including:

[0053] Create an EDP data dictionary, iterate through the calculation results of inelastic hinges, extract the unit number and the corresponding rotation angle values ​​on the I and J ends, filter to obtain the maximum rotation angle, and store them one by one in the EDP data dictionary with the component unit number as the key and the maximum rotation angle under each time history condition as the value.

[0054] The calculation results of the acceleration of each floor node are iterated through, and the maximum value of the acceleration of all nodes on the same floor and its corresponding floor number are selected. The floor number is used as the key and the maximum acceleration under each time history load condition is used as the value. The results are stored one by one in the EDP data dictionary.

[0055] Convert the EDP data dictionary into an array format to form an EDP matrix, and export it to the specified directory in .xlsx format.

[0056] According to the second aspect, one embodiment provides a system for rapidly constructing a structural engineering requirement parameter matrix for railway passenger stations, the system comprising:

[0057] The structural model and floor group creation module is used to create or import railway passenger station structural models in MIDAS Gen software and create floor groups.

[0058] The API call function creation module is used to create MIDAS API call functions in the Python platform;

[0059] The time-history load function creation module is used in the Python environment to construct time-history load function requests and use the MIDAS API to call functions to send the time-history load function requests to the Midas Gen software via POST requests, thus automatically completing the creation of time-history load functions.

[0060] The Time-History Load Case Creation Module is used in the Python environment to construct time-history load case requests and use the MIDAS API to call functions to send the time-history load case requests to the Midas Gen software via POST requests, thereby automatically completing the creation of time-history load cases.

[0061] The ground acceleration creation module is used in the Python environment to build ground acceleration requests, and then use the MIDASAPI to call functions to send the ground acceleration requests to the Midas Gen software in the form of POST requests, so as to automatically complete the creation of ground acceleration.

[0062] The execution time history analysis calculation module is used in the Python environment to first use the MIDAS API to call functions and send a file save request to the Midas Gen software in the form of a POST request to save the calculation file. Then, it sends a calculation analysis request to the Midas Gen software in the form of a POST request to execute the calculation of all time history analysis conditions.

[0063] The calculation result extraction module is used in the Python environment to create non-elastic hinge requests for components, and use the MIDAS API to call functions to send the non-elastic hinge requests to the Midas Gen software in the form of POST requests, automatically obtaining the calculation results of all non-elastic hinges; it also iterates through each floor of the structure, creates acceleration requests for all nodes on each floor, and uses the MIDAS API to call functions to send the acceleration requests for all nodes on each floor to the MidasGen software in the form of POST requests, automatically obtaining the calculation results of the acceleration of the corresponding nodes on each floor;

[0064] The matrix construction module is used to extract the rotation angle and floor acceleration of key components under various time-history load conditions based on the calculation results of inelastic hinges and the acceleration of each floor node, and assemble them into an engineering requirement parameter matrix.

[0065] This invention provides a method and system for rapidly constructing a structural engineering requirement parameter matrix for railway passenger stations, which has the following beneficial effects:

[0066] (1) Based on the API interface opened by the Midas Gen design software, this invention establishes a method for rapidly constructing the structural engineering requirement parameter matrix of railway passenger stations. It realizes the automated setting of the model's time history load function, time history load conditions, ground acceleration and other preprocessing work, as well as the batch calculation of elastoplastic time history analysis, which significantly improves the extraction efficiency of component rotation angle and floor acceleration, and greatly improves the convenience of seismic toughness assessment of railway passenger stations.

[0067] (2) The engineering requirement parameter construction method proposed in this invention is simple in logic and clear in operation, which reduces the learning and operation costs of engineers for complex toughness assessment methods, such as complex finite element elastoplastic analysis and pre- and post-processing, matrix (array) data conversion and analysis, etc. At the same time, it has flexible scalability, which can meet the secondary development needs of other functional modules in the later stage, and facilitates engineering promotion and application. Attached Figure Description

[0068] Figure 1 A flowchart illustrating a method for rapidly constructing a structural engineering requirement parameter matrix for railway passenger stations, as provided in one embodiment of the present invention;

[0069] Figure 2 This is a flowchart illustrating a method for rapidly constructing a structural engineering requirement parameter matrix for railway passenger stations, as provided in one embodiment of the present invention.

[0070] Figure 3 This is a logical architecture diagram of calling the MIDAS API in a method for rapidly constructing a structural engineering requirement parameter matrix for railway passenger stations, provided in one embodiment of the present invention.

[0071] Figure 4 This invention provides a time-history load function in a method for rapidly constructing a structural engineering requirement parameter matrix for railway passenger stations, as an embodiment of the present invention.

[0072] Figure 5 This invention provides a method for rapidly constructing a structural engineering requirement parameter matrix for railway passenger stations, including time-history load cases, as an embodiment of the present invention.

[0073] Figure 6 Ground acceleration is provided in a method for rapidly constructing a structural engineering requirement parameter matrix for railway passenger stations according to an embodiment of the present invention.

[0074] Figure 7 The structural engineering parameter matrix is ​​obtained by a method for rapidly constructing a structural engineering requirement parameter matrix for railway passenger stations, as provided in one embodiment of the present invention. Detailed Implementation

[0075] The present invention will now be described in further detail with reference to specific embodiments and accompanying drawings. Similar elements in different embodiments are referred to by associated similar element reference numerals. In the following embodiments, many details are described to facilitate a better understanding of the invention. However, those skilled in the art will readily recognize that some features may be omitted in different situations, or may be replaced by other elements, materials, or methods. In some cases, certain operations related to the present invention are not shown or described in the specification. This is to avoid obscuring the core parts of the invention with excessive description. For those skilled in the art, detailed description of these related operations is not necessary; they can fully understand the related operations based on the description in the specification and general technical knowledge in the art.

[0076] Furthermore, the features, operations, or characteristics described in the specification can be combined in any suitable manner to form various embodiments. At the same time, the steps or actions in the method description can be rearranged or adjusted in a manner obvious to those skilled in the art. Therefore, the various orders in the specification and drawings are only for the clear description of a particular embodiment and do not imply a necessary order, unless otherwise stated that a particular order must be followed.

[0077] The first embodiment of this invention provides a method for rapidly constructing a structural engineering demand parameter matrix for railway passenger stations. Based on the application programming interface (API) of the MIDAS Gen design software, and using the Python programming language, it automatically creates and sets the time-history load functions, time-history load cases, and ground acceleration of the railway passenger station structural model. Then, it performs batch elastoplastic time-history analysis to extract the rotation angles of inelastic hinges of key components and the inter-story accelerations. Finally, it automatically assembles and forms an engineering demand parameter (EDP) matrix, significantly improving the convenience and feasibility of seismic toughness assessment for railway passenger stations. The following is a related explanation. Figure 1 and Figure 2 Please provide a detailed explanation.

[0078] Step 1: Create a structural model: In MIDAS Gen software, create or import the railway passenger station structural model to be analyzed, set the inelastic hinge characteristic values ​​of beams, columns, and supports respectively, including: element type, material type, type, location, and hysteresis model of plastic hinges, and assign the inelastic hinge characteristic values ​​to the corresponding components.

[0079] Step 2: Create floor groups: Based on the model floor information in the MIDAS Gen software, create floor groups in the structure group, and assign the nodes and units of the corresponding floors to the corresponding floor groups.

[0080] Step 3: Create API call functions: Create MIDAS API call functions in the Python platform (e.g., ... Figure 3 As shown, based on the server address (url) and the access authentication key (MAPI Key), an HTTP request is sent using the Requests library, and corresponding operations are performed based on different HTTP request headers and request body content.

[0081] HTTP requests include POST (Create Resource), PUT (Update Resource), GET (Get Resource), and DELETE (Delete Resource).

[0082] Step 4: Create a time-history load function: In the Python environment, automatically read the seismic wave data from the specified directory and extract the time series value t line by line. i and acceleration sequence value a i And combine them into a dictionary format Fun_Dic = {"TIME":[t1, t2, t3……, t} n ], "VALUE": [a1, a2, a3,……, a n Further construct the request body Time_Func_json of the time-scheduling load function, and use the MIDAS API call function created in step three to send the corresponding request header Time_Func_header and request body Time_Func_json to the Midas Gen software in the form of a POST request to automatically complete the creation of the time-scheduling load function.

[0083] Among them, the seismic wave data are near-field and far-field natural seismic wave records after amplitude adjustment according to the design intensity.

[0084] The steps for setting the Time_Func_json request body of the time-history load function are as follows:

[0085] Step 4.1: Set the load function name, select the time history load function type, and set the time function data type to dimensionless acceleration;

[0086] Step 4.2: Determine the ground motion modulation coefficient and gravitational acceleration;

[0087] Step 4.3: Assign the seismic wave data dictionary Fun_Dic to the function data.

[0088] The Time_Func_header request header for the time-history load function is " / db / thfc".

[0089] Step 5: Create Time-History Load Cases: In the Python environment, input the natural period T1 and damping ratio ξ1 of the first vibration mode, and the natural period T2 and damping ratio ξ2 of the second vibration mode. The system will automatically read the seismic wave data from the specified directory and iteratively extract the duration t0, time step Δt, and total time step n for each seismic wave. t Further, the request body Time_Case_json of the time-history load case is constructed. Using the MIDAS API call function created in step three, the corresponding request header Time_Case_header and request body Time_Case_json are sent to the Midas Gen software in the form of a POST request to automatically complete the creation of the time-history load case.

[0090] The steps for setting the Time_Case_json request body for time-history load cases are as follows:

[0091] Step 5.1: Set the load case name, select nonlinear time history dynamic analysis as the analysis type, select direct integration method as the analysis method, and select transient time history type. Set the analysis time to the seismic wave duration t0, the analysis time step to the time step Δt, and the output time step to the total time step n. t ;

[0092] Step 5.2: Select the loading sequence mode, use static load (ST) as the load case to continue from the previous load case, and select not to consider geometric nonlinearity;

[0093] Step 5.3: Select the damping calculation method for mass and stiffness factors. The mass and stiffness factors are obtained through model damping calculation, and the period T1 and damping ratio ξ1 of the first mode and the period T2 and damping ratio ξ2 of the second mode are input respectively.

[0094] Step 5.4: Select the Newmark method as the direct integration method for the numerical integration of the dynamic equations, and input the parameters GAMA=0.5 and BETA=0.25 using the constant acceleration method;

[0095] Step 5.5: Set the minimum iteration step size for nonlinear analysis to 1×e -5 The maximum number of iterations was set to 10. Displacement and force convergence criteria were selected, and the convergence value was set to 0.001. Furthermore, the Fehlberg-based Runge-Kutta method was chosen as the boundary nonlinear analysis method, and the tolerance error was set to 1×e. -8 .

[0096] The Time_Case_header for the time-history load case request is " / db / this".

[0097] Step Six: Create Ground Acceleration: In the Python environment, determine the direction of ground acceleration (Dir) and the angle of ground acceleration (Ang). Using the MIDAS API call function created in Step Three, retrieve all currently created time-history load functions and time-history load cases in the MidasGen software via a GET request. Iterate through these load cases to obtain the name of each load function (Time_Func_Name(i)) and the name of each load case (Time_Case_Name(i)). Further determine the direction of ground acceleration (Dir), construct the ground acceleration request body (Ground_Acce_json), and use the MIDAS API call function created in Step Three to send the corresponding request header (Ground_Acce_header) and request body (Ground_Acce_json) to the Midas Gen software via a POST request, automatically completing the creation of the ground acceleration.

[0098] The ground acceleration direction Dir includes the X, Y, and Z directions.

[0099] The steps for setting up the Ground Acceleration Request body (Ground_Acce_json) are as follows:

[0100] Step 6.1: Set the time-history load case name to Time_Case_Name(i);

[0101] Step 6.2: Based on the direction of ground acceleration Dir, set the time history load function in the corresponding direction to Time_Func_Name(i), and set the adjustment coefficient of ground acceleration and the time when it starts to act on the structure;

[0102] Step 6.3: Set the angle of the horizontal ground acceleration to Ang.

[0103] The Ground Acceleration Request header is " / db / thga".

[0104] Step 7: Perform time history analysis calculations: In the Python environment, using the MIDAS API call function created in Step 3, send the file save request header " / doc / save" to the Midas Gen software via a POST request to save the calculation file. Then, send the calculation analysis request header " / doc / analy" to the MidasGen software via a POST request to execute calculations for all time history analysis conditions.

[0105] Step 8: Extract the calculation results of inelastic hinges and nodal accelerations: In the Python environment, using the MIDAS API call function created in Step 3, retrieve all currently created time-history load cases in the MidasGen software via a GET request. Iterate through each load case to obtain its name (Time_Case_Name(i)), further determine the direction of ground acceleration (Dir), create the corresponding inelastic hinge request body (Inelastic_Hinge_json), and send the corresponding request header (Inelastic_Hinge_header) and request body (Inelastic_Hinge_json) to the MidasGen software via a POST request. This automatically retrieves the calculation results of all inelastic hinges. Iterate through each floor of the structure, creating a node acceleration request header (Node_Acce_header) and request body (Node_Acce_json) for each floor, and send them to the MidasGen software. This automatically retrieves the calculation results of the corresponding node accelerations for each floor.

[0106] The steps for setting up the Inelastic_Hinge_json file for the component's inelastic hinge request body are as follows:

[0107] Step 8.1.1: Select the inelastic hinge type as concentrated inelastic hinge;

[0108] Step 8.1.2: Set the data export path, data unit, and data format. The exported data includes the unit number and the corresponding rotation angle.

[0109] Step 8.1.3: Select the corresponding time-history load case as Time_Case_Name(i).

[0110] The steps for setting the Node_Acce_json header are as follows:

[0111] Step 8.2.1: Select absolute acceleration as the nodal acceleration type;

[0112] Step 8.2.2: Set the data export path, data unit, and data format. The data export content includes node number, load type, and acceleration direction.

[0113] Step 8.2.3: Obtain the node number layer by layer using the floor group from Step 2;

[0114] Step 8.2.4: Select the corresponding time-history load case as Time_Case_Name(i).

[0115] Among them, the Inelastic_Hinge_header for component inelastic hinges and the Node_Acce_header for node acceleration are " / post / table".

[0116] Step 9: Assemble and export the Engineering Requirements Parameter EDP matrix: Based on the calculation results of inelastic hinges and nodal accelerations, extract the rotation angle θ and floor acceleration FPA of key components under each time-history load condition, assemble the Engineering Requirements Parameter EDP matrix, and export it to the specified directory in .xlsx format.

[0117] The extraction methods for component rotation angle θ and floor acceleration FPA, and the assembly steps for the engineering requirement parameter matrix are as follows:

[0118] Step 9.1: Create an EDP data dictionary, iterate through the calculation results of the inelastic hinge, extract the unit number and the corresponding rotation angle value on the I and J ends, filter to obtain the maximum rotation angle, and store them one by one in the EDP data dictionary with the component unit number as the key and the maximum rotation angle under each time history condition as the value.

[0119] Step 9.2: Iterate through the calculation results of the acceleration of each floor node, filter out the maximum acceleration of all nodes on the same floor and its corresponding floor number, and store them one by one in the EDP data dictionary with the floor number as the key and the maximum acceleration under each time history as the value.

[0120] Step 9.3: Convert the EDP data dictionary into an array format to form an EPD matrix.

[0121] Application example:

[0122] Applying the technology of this invention, inelastic hinge characteristic values ​​are set for beams, columns, and supports. Specifically, 648 beams and 251 columns use a concentrated plastic hinge model, and 48 supports use truss elements. Then, nine floor groups are created: floor 1 with 85 nodes, floor 2 with 2503 nodes, floor 3 with 1752 nodes, floor 4 with 1423 nodes, floor 5 with 1472 nodes, floor 6 with 105 nodes, floor 8 with 17 nodes, and floor 9 with 105 nodes. Seismic wave data from a specified folder is automatically read. The seismic wave data consists of 39 far-field ground motion data points after amplitude modulation with 0.5g acceleration. The time-history load function is automatically created, as follows... Figure 4 As shown. Then, based on the modal analysis results, inputting the natural period T1=0.5840 and damping ratio ξ1=0.05 for the first vibration mode and the natural period T2=0.5546 and damping ratio ξ2=0.05 for the second vibration mode, the system automatically creates time-history load cases, as shown. Figure 5As shown. By defining the direction of ground acceleration as X and the angle of ground acceleration as 0, the ground acceleration is automatically created, as follows. Figure 6 As shown. Calculations are performed for all time-history analysis cases, extracting the calculation results for inelastic hinges and nodal accelerations. The rotation angle θ and floor acceleration FPA of key components under each time-history load case are extracted, and the Engineering Requirements Parameter (EDP) matrix is ​​assembled, as follows. Figure 7 As shown, this invention enables the rapid construction of structural engineering requirement parameter matrices in a clear and concise manner, improving the convenience and feasibility of seismic toughness assessment for railway passenger stations.

[0123] Corresponding to the aforementioned method for rapidly constructing a demand parameter matrix for railway passenger station structural engineering, this invention also discloses a system for rapidly constructing a demand parameter matrix for railway passenger station structural engineering, which specifically includes:

[0124] The structural model and floor group creation module is used to create or import railway passenger station structural models in MIDAS Gen software and create floor groups.

[0125] The API call function creation module is used to create MIDAS API call functions in the Python platform;

[0126] The time-history load function creation module is used in the Python environment to construct time-history load function requests and use the MIDAS API to call functions to send the time-history load function requests to the Midas Gen software via POST requests, thus automatically completing the creation of time-history load functions.

[0127] The Time-History Load Case Creation Module is used in the Python environment to construct time-history load case requests and use the MIDAS API to call functions to send the time-history load case requests to the Midas Gen software via POST requests, thereby automatically completing the creation of time-history load cases.

[0128] The ground acceleration creation module is used in the Python environment to build ground acceleration requests, and then use the MIDASAPI to call functions to send the ground acceleration requests to the Midas Gen software in the form of POST requests, so as to automatically complete the creation of ground acceleration.

[0129] The execution time history analysis calculation module is used in the Python environment to first use the MIDAS API to call functions and send a file save request to the Midas Gen software in the form of a POST request to save the calculation file. Then, it sends a calculation analysis request to the Midas Gen software in the form of a POST request to execute the calculation of all time history analysis conditions.

[0130] The calculation result extraction module is used in the Python environment to create non-elastic hinge requests for components, and use the MIDAS API to call functions to send the non-elastic hinge requests to the Midas Gen software in the form of POST requests, automatically obtaining the calculation results of all non-elastic hinges; it also iterates through each floor of the structure, creates acceleration requests for all nodes on each floor, and uses the MIDAS API to call functions to send the acceleration requests for all nodes on each floor to the MidasGen software in the form of POST requests, automatically obtaining the calculation results of the acceleration of the corresponding nodes on each floor;

[0131] The matrix construction module is used to extract the rotation angle and floor acceleration of key components under various time-history load conditions based on the calculation results of inelastic hinges and the acceleration of each floor node, and assemble them into an engineering requirement parameter matrix.

[0132] It should be noted that for a detailed description of the system for rapidly constructing a railway passenger station structural engineering requirement parameter matrix provided in the embodiments of the present invention, please refer to the relevant description of the method for rapidly constructing a railway passenger station structural engineering requirement parameter matrix provided in the embodiments of the present invention, which will not be repeated here.

[0133] Those skilled in the art will understand that all or part of the functions of the various methods in the above embodiments can be implemented by hardware or by computer programs. When all or part of the functions in the above embodiments are implemented by computer programs, the program can be stored in a computer-readable storage medium, which may include: read-only memory, random access memory, disk, optical disk, hard disk, etc., and the program is executed by a computer to achieve the above functions. For example, the program can be stored in the memory of a device, and when the program in the memory is executed by the processor, all or part of the above functions can be achieved. In addition, when all or part of the functions in the above embodiments are implemented by computer programs, the program can also be stored in a server, another computer, disk, optical disk, flash drive, or external hard drive, etc., and can be downloaded or copied to the memory of a local device, or the system of the local device can be updated. When the program in the memory is executed by the processor, all or part of the functions in the above embodiments can be achieved.

[0134] The above examples illustrate the present invention only to aid in understanding it and are not intended to limit the scope of the invention. Those skilled in the art can make various simple deductions, modifications, or substitutions based on the principles of this invention.

Claims

1. A method for rapidly constructing a structural engineering requirement parameter matrix for railway passenger stations, characterized in that, The method includes: Create or import a railway passenger station structure model into MIDAS Gen software and create floor groups; Create a MIDAS API call function on the Python platform; In the Python environment, a time-history load function request is constructed, and the function is called using the MIDAS API. The time-history load function request is sent to the Midas Gen software via a POST request, which automatically completes the creation of the time-history load function. In the Python environment, a time-history load case request is constructed, and the MIDAS API is used to call functions to send the time-history load case request to the Midas Gen software via POST request, which automatically completes the creation of the time-history load case. In the Python environment, a ground acceleration request is constructed, and then the MIDAS API is used to call functions to send the ground acceleration request to the Midas Gen software in the form of a POST request, which automatically completes the creation of the ground acceleration. In the Python environment, the MIDAS API is first used to call functions to send a file save request to the Midas Gen software via POST request to save the calculation file. Then, the calculation analysis request is sent to the MidasGen software via POST request to execute the calculations for all time history analysis conditions. In the Python environment, a non-elastic hinge request for a component is created. The MIDAS API is used to call a function to send the non-elastic hinge request to the Midas Gen software via a POST request, automatically obtaining the calculation results of all non-elastic hinges. The system then iterates through each floor of the structure, creating acceleration requests for all nodes on each floor. The MIDAS API is then used to call a function to send the acceleration requests for all nodes on each floor via a POST request, automatically obtaining the calculation results of the acceleration of the corresponding nodes on each floor. Based on the calculation results of inelastic hinges and the acceleration of each floor node, the rotation angle and floor acceleration of key components under each time-history load condition are extracted and assembled into an engineering requirement parameter matrix.

2. The method for rapidly constructing a structural engineering requirement parameter matrix for railway passenger stations as described in claim 1, characterized in that, Create or import a railway passenger station structure model in MIDAS Gen software and create floor groups, specifically including: In MIDAS Gen software, create or import the railway passenger station structure model to be analyzed, and set the inelastic hinge characteristic values ​​of beams, columns, and supports respectively, and assign the inelastic hinge characteristic values ​​to the corresponding components. Based on the model floor information in the MIDAS Gen software, create floor groups in the structure group and assign the nodes and units of the corresponding floors to the corresponding floor groups.

3. The method for rapidly constructing a structural engineering requirement parameter matrix for railway passenger stations as described in claim 1, characterized in that, Creating MIDAS API call functions on the Python platform, specifically including: Create a function to call the MIDAS API in the Python platform. Based on the server address URL and access authentication key MAPIKey, use the Requests library to send an HTTP request and perform corresponding operations based on different HTTP request headers and request body content. HTTP requests include POST (Create Resource), PUT (Update Resource), GET (Get Resource), and DELETE (Delete Resource).

4. The method for rapidly constructing a structural engineering requirement parameter matrix for railway passenger stations as described in claim 1, characterized in that, In the Python environment, a time-history load function request is constructed, and the MIDAS API is used to call the function. The time-history load function request is sent to the Midas Gen software via a POST request, automatically completing the creation of the time-history load function. Specifically, this includes: In a Python environment, automatically read seismic wave data from a specified directory and extract time series values ​​t line by line. i and acceleration sequence value a i And combine them into a dictionary Fun_Dic; Construct the TimeFunc_json body of the time-scheduled load function request, including: Set the time history load function name, select the time history load function type, and set the time function data type to dimensionless acceleration; Determine the ground motion modulation coefficient and gravitational acceleration; Assign values ​​from the seismic wave data dictionary Fun_Dic to the function data.

5. The method for rapidly constructing a structural engineering requirement parameter matrix for railway passenger stations as described in claim 1, characterized in that, In the Python environment, a time-history load case request is constructed, and the MIDAS API is used to call functions to send the time-history load case request to the Midas Gen software via a POST request, automatically completing the creation of the time-history load cases. Specifically, this includes: In the Python environment, input the natural period T1 and damping ratio ξ1 of the first vibration mode of the structure, and the natural period T2 and damping ratio ξ2 of the second vibration mode, and the system will automatically read the seismic wave data from the specified directory and extract the duration, time step and total time step of each seismic wave in a loop. Construct the Time_Case_json body of the time-history load case request, including: Set the load case name, select nonlinear time history dynamic analysis as the analysis type, select direct integration method as the analysis method, select transient time history type, and set the analysis time to the duration t0 of the seismic wave, the analysis time step to the time step Δt, and the output time step to the total time step n. t ; Choose the loading sequence method, use static load as the successor to the previous load case, and choose not to consider geometric nonlinearity. Select the damping calculation method for mass and stiffness factors, where the mass and stiffness factors are obtained through model damping calculation, and the natural period T1 and damping ratio ξ1 of the first mode and the natural period T2 and damping ratio ξ2 of the second mode are respectively input. The Newmark method was chosen as the direct integration method for the numerical integration of the dynamic equations. Set the minimum iteration step size and maximum number of iterations for the nonlinear analysis, select the displacement convergence criterion and the force convergence criterion respectively, and set the convergence value; further select the Fehlberg-based Runge-Kutta method as the boundary nonlinear analysis method, and set the allowable error.

6. The method for rapidly constructing a structural engineering requirement parameter matrix for railway passenger stations as described in claim 1, characterized in that, In the Python environment, a ground acceleration request is constructed, and then the MIDAS API is used to call functions to send the ground acceleration request to the Midas Gen software via a POST request, automatically completing the creation of the ground acceleration data. Specifically, this includes: In the Python environment, the ground acceleration direction Dir and ground acceleration angle Ang are determined. The created MIDAS API call function is used to obtain all time-history load functions and time-history load cases currently created in the Midas Gen software by using a GET request. The name of each time-history load function Time_Func_Name(i) and the name of each time-history load case Time_Case_Name(i) are obtained by looping through them. Further determine the direction of ground acceleration, Dir, and create a ground acceleration request body, Ground_Acce_json, including: Set the time-history load case name to Time_Case_Name(i); Based on the direction of ground acceleration Dir, set the time history load function in the corresponding direction to Time_Func_Name(i), and set the adjustment coefficient of ground acceleration and the time when it begins to act on the structure; Set the angle of the horizontal ground acceleration to Ang.

7. The method for rapidly constructing a structural engineering requirement parameter matrix for railway passenger stations as described in claim 6, characterized in that, In the Python environment, a non-elastic hinge request for a component is created. Using the MIDAS API, a function is called to send the non-elastic hinge request to the Midas Gen software via a POST request. The software automatically retrieves the calculation results for all non-elastic hinges, specifically including: In the Python environment, the created MIDAS API call function is used to obtain all time-history load cases currently created in the Midas Gen software via GET request, and the name of each load case, Time_Case_Name(i), is obtained by looping through it. Further determine the direction of ground acceleration, Dir, and create a component inelastic hinge request body, Inelastic_Hinge_json, including: Select the inelastic hinge type as concentrated inelastic hinge; Set the data export path, data unit, and data format. The exported data includes the unit number and the corresponding rotation angle. Select the corresponding time-history load case as Time_Case_Name(i).

8. The method for rapidly constructing a structural engineering requirement parameter matrix for railway passenger stations as described in claim 1, characterized in that, The algorithm iterates through each floor of the structure, creating acceleration requests for all nodes on each floor. Then, using the MIDAS API, it sends these acceleration requests to the Midas Gen software via a POST request, automatically retrieving the acceleration calculation results for each floor's corresponding nodes. Specifically, this includes: Create the Node_Acce_json header for all nodes on each floor, including: Select absolute acceleration as the nodal acceleration type; Set the data export path, data unit, and data format. The data export content includes node number, time history load type, and acceleration direction. Obtain node numbers layer by layer by creating floor groups; Select the corresponding time-history load case as Time_Case_Name(i).

9. The method for rapidly constructing a structural engineering requirement parameter matrix for railway passenger stations as described in claim 1, characterized in that, Based on the calculation results of inelastic hinges and the acceleration of each floor node, the rotation angle and floor acceleration of key components under each time-history load case are extracted and assembled into an engineering requirement parameter matrix, which specifically includes: Create an EDP data dictionary, iterate through the calculation results of inelastic hinges, extract the unit number and the corresponding rotation angle values ​​on the I and J ends, filter to obtain the maximum rotation angle, and store them one by one in the EDP data dictionary with the component unit number as the key and the maximum rotation angle under each time history condition as the value. The calculation results of the acceleration of each floor node are iterated through, and the maximum value of the acceleration of all nodes on the same floor and its corresponding floor number are selected. The floor number is used as the key and the maximum acceleration under each time history load condition is used as the value. The results are stored one by one in the EDP data dictionary. Convert the EDP data dictionary into an array format to form an EDP matrix, and export it to the specified directory in .xlsx format.

10. A system for rapidly constructing a structural engineering requirement parameter matrix for railway passenger stations, characterized in that, The system includes: The structural model and floor group creation module is used to create or import railway passenger station structural models in MIDAS Gen software and create floor groups. The API call function creation module is used to create MIDAS API call functions in the Python platform; The time-history load function creation module is used in the Python environment to construct time-history load function requests and use the MIDASAPI to call functions to send the time-history load function requests to the Midas Gen software via POST requests, thus automatically completing the creation of time-history load functions. The Time-History Load Case Creation Module is used in the Python environment to construct time-history load case requests and use the MIDASAPI to call functions to send the time-history load case requests to the Midas Gen software via POST requests, thereby automatically completing the creation of time-history load cases. The ground acceleration creation module is used in the Python environment to build ground acceleration requests, and then use the MIDAS API to call functions to send the ground acceleration requests to the Midas Gen software in the form of POST requests, so as to automatically complete the creation of ground acceleration. The execution time history analysis calculation module is used in the Python environment to first use the MIDAS API to call functions and send a file save request to the Midas Gen software in the form of a POST request to save the calculation file. Then, it sends a calculation analysis request to the Midas Gen software in the form of a POST request to execute the calculation of all time history analysis conditions. The calculation result extraction module is used in the Python environment to create non-elastic hinge requests for components, and use the MIDAS API to call functions to send the non-elastic hinge requests to the Midas Gen software in the form of POST requests, automatically obtaining the calculation results of all non-elastic hinges; it also iterates through each floor of the structure, creates acceleration requests for all nodes on each floor, and uses the MIDAS API to call functions to send the acceleration requests for all nodes on each floor to the Midas Gen software in the form of POST requests, automatically obtaining the calculation results of the acceleration of the corresponding nodes on each floor; The matrix construction module is used to extract the rotation angle and floor acceleration of key components under various time-history load conditions based on the calculation results of inelastic hinges and the acceleration of each floor node, and assemble them into an engineering requirement parameter matrix.

Images