This app checks the rigging and the crane according to the DNV standards. According to the DNV standard, the skew load factor is a standard value. With the help of a python script, it is possible to calculate this more in detail. After the calculations are done, with the help of the Viktor program an automatic word document will be generated. The skew load factor is explained in the skewload.md document First, the rigging checks were made in an excel sheet, with the help of this app it will be more user-friendly.
Dit moet ik nog uitvogelen aan de hand van de documentatie van viktor
A pdf manual can be donwloaded in folder "Files_read_me"
See below the tree structure of the app, in the Rigging_app folder are all the python scripts. See below what all files do:
- Calculations: All code for calculations is in this file
- The controller responds to the user input and performs interactions on the data model objects. The controller receives the input, optionally validates it, and then passes the input to the model.
- The model is responsible for managing the data of the application. It receives user input from the controller
- Default_inputs: This is responsible for transforming the data from the excel file to useful data and is responsible for the standard values of the different tables.
- Folder Data_input: All data input is put in this file
- Folder Data_output: All data output is put in this file
- parametrization: Responsible for creating the frontend of the application
app/
┣ Data_input/
┃ ┣ Constants_DNV.xlsx
┃ ┗ Data_lifting_tools.xlsx
┣ Data_output/
┃ ┣ Results_SKL.csv
┃ ┣ Top_view.png
┃ ┗ Word_template.docx
┣ Rigging_app/
┃ ┣ calculations.py
┃ ┣ controller.py
┃ ┣ Default_inputs.py
┃ ┣ model.py
┃ ┣ parametrization.py
┃ ┗ __init__.py
┗ __init__.py
In this chapter the workflow diagram is described, see below the the total workflow diagram
In the upper part of the fiure, the front end of the app is shown. The front end of the app consists of 5 different tabs, each tab has a different kind of input fields and buttons. The parameters that are filled are explained in more detail in the chapter "Input". On the left side, the databases are shown, Both these databases are excel sheets and the data in these files can easily be changed. With the help of the module openpyxl, the data from the excel sheet is transformed to useful data, in the default_inputs file
All the params and data from the excel sheets are passed to the communication class, in the module file. The first thing the class does is change the params into useful data, in which way it is stored can be seen in the next chapter. When all the data is transformed, the calculations are done, These are:
- The cog envelope (Class: Calc_COG_env)
- Load distributie/ Cog shift factor (Class: Calc_load_dis))
- Tilt factor (Class: Tilt factor)
- Calculations of the factors that are descibed in next chapter: tab_3 (Class: Calc_factors)
- Calculated the rigging checks and unity check(Class: Calc_rigging)
- Caluclated crane checks and unity check(Class: Calc_crane)
All the data from the parameters and the data from the results from the calculations are attributed to the communication class, so it can be used in other methods. With the help of the property method, the data can be retrieved, so it can be shown in 3 different tabs( see the part under communication class):
- First tab:
- Ouput load distributie[t]
- Output load distributie[%]
- Output all factors
- Second tab: Checks rigging
- Third tab: Checks crane
Both the skew load analysis and the make word document are not in the communication class, because every time a params is changed in one of the 5 tabs. The communication class will be activated and those two actions take a lot of time, this is why it is done with the help of buttons. When the skew load analysis button is pressed, first it gets the data from the communication class and it will analyze the skew load factor, when the analysis is done the result will be stored in a CSV file, so it can be retrieved when making the word document.
When the word document button is activated, it takes all data and results from the calculations from the communication class, also the file params. Then based on the lift points and the geometry of the object, a top-view picture is made. These are params such as the date/the project no/ company name. With the help of the jinja notations, the results and data are transformed into readable rigging check documentation, this word document can be downloaded via the internet and can be changed where necessary.
The front off the app is made with the help of the viktor program, in total there are 5 different input apps: See below:
In tab 1 the general information is entered:
- Number of lifting points
- Coardinates of lifting points
- COG point
- Lift object geometry
- Lift object weight
- Coardinates of lifting points
With the help of the method make_data_general the data is stored in the structure, that is shown below:
Data_general={"Lift_points": [nx[float(point_x),float(point_y),float(point_z),float(x_deg),float(y_deg)]],
"Obj_geo": [float(length),float(width),float(height],
"COG": [float(COG_x),float(COG_y),float(COG_z],
"LW": float(weight of liftobject)}
In de lift points, the n is equal to number of lifting points
In tab 2, the values for the Factors, sling safety factor and the skew load factor are entered. In section 1the parameters for the factors are entered, those are:
- Answer weight continency factor
- Answer COG shift factor crane
- Answer COG shift factor rigging
- Answer dynamic amplication factor
- Answer YAW factor
- Angles Tilt factor
With the help of the method make_general factors the data is stored in a diactionary structure, that is shown below:
Data_general_factor={"WCF":str(answer),
"COGCrane":str(answer),
"COG_envelope":str(answer),
"DAF":str(answer),
"YAW":str(answer),
"TEF":[float(Roll angle), float(Pitch angle)],
"SKL_analysis": Bool}
In section 2 the values for the sling safetry factor are entered, the params are:
- Anwer Lift factor
- Answer Material factor
- Answer Consequence factor
- Answer Wear/application factor
With the help of the method make_data_SSF_factor factors the data is stored in a array with a number of dictionaries that depends on the number of sling safety factors, see below code snippet:
Data_sling_safetry=[{"Lift_factor":float(answer),
"Consequence_factor":float(answer),
"material_factor":str(answer,
"Wear_application_factor":str(answer}]
The answers for the skew load factor are entered in section 3, see other page.
In tab 3, the values for the rigging check are entered
- Name of the rigging point
- Material of the sling/grommet
- Which points are connected
- Rigging weight above the lifting point
- Sling angle with the transverse
- Sling angle with the longitudinal
- Sling safety factor
- Termination factor
- Skew load factor
- Sldf factor
- Type sling:
- Amount of parts
- ID(SWL and diameter)
- Connection upper side sling/grommet:
- Type
- Diameter
- SWL
- Connection lower side sling/grommet:
- Type
- Diameter
- SWL
With the help of the method make_data_rigging factors the data is stored in a array with a number of dictionaries that depends on the rigging points that needs to be checked, see below code snippet:
Data_rigging=[{"Name": str(rigging_point_name),
"Materal": str(Material sling/grommet),
"Points": list(points connected to the rigging),
"RWP": float(rigging weight),
"Angle_1": float(transvere_angle),
"Angle_2": float(longitudinal_angle),
"TRF_ans": str(answer TRF factor)
"SSF_ans": str(Sling safety factor),
"SKL": [str(answer skl), int(the sling from the analyes)],
"SLDF" : str(ans sling load distribution factor),
"sling":[str(id_number),str(type),float(swl),float(diameter),float(n_parts)],
"Connection_upper":[str(type),float(diameter),float(swl],
"Connection_lower":[str(type),float(diameter),float(swl]
}]
In tab 4, the values for the crane check are entered
- Which crane lifts the lifting point
- Which hoist lifts the lifting point
- The capacity of the hoist
- The offlead angle of the hoists
With the help of the method make_data_cranes the data is stored in the a dictionary see code snippet below:
data_crane{str(Crane_name):{"DDF": float(DDF_factor),
str(hoist): "Data":[float(Capacity),float(off_lead),float(RW)],
"Points": list(points that are lifted by hoist)}
If there are multiple cranes used the, there will be two crane names in the keys of the dictionary data_cran, there is a max of two cranes that can be used. If there are multiple hoist used, there will be a hoist added in the diactionary data_crane[Crane_name], with the right info.
According to the DNV standard, rigging equipment has a tolerance of 0.25%, what this means is that the sling/grommet maybe 0.25% shorter or 0.25% longer than the original length. This affects all types of lifts, as the load can end up hanging askew. But on a four-point lift, this can affect the force distribution of the slings. According to the DNV standard, the factor for each sling is equal to 1.25, in reality, this factor depends on several values. Such as the in-service length of the slings, the elasticity modulus, the diameter, and the coordinates of both the lift points and the hook. Therefore, it is necessary to see how different lengths affect the forces in the slings, with an iterative process the skew load factor can be determined in more detail.
With the help of the method make_skl_data the data is stored in the following structure, see code snippet below:
Data_skl={"Lift_points": [nx[float(point_x),float(point_y),float(point_z)]],
"ESlings": [float(Esling1),float(Esling2),float(Esling3],float(Esling4)],
"Hook_point": [float(Hook_x),float(Hook_y),float(Hook_z],
"DSlings": [float(Dsling1),float(Dsling2),float(Dsling3],float(Dsling4)],
"LSlings": [float(Lsling1),float(Lsling2),float(Lsling3],float(Lsling4)]}
For a more detailed description see "EngineeringsModel_skl.pdf" in the folder "Files_read_me"
-
Determine the stiffness constant of the slings
The sitfness method is determined bases on the E-modulus, Core diameter and the effective work length -
Determine force in slings, with the effective work length
Determine the force in the slings, with the effective work length. It is determine used using step 4,5,6,7,8 and 9. It is possible that some cables are pulled sooner than other, due to the different effective work length. -
Determine length slings, with tolerance
Calculate the length of the slings based on the tolerance it is possible that the lenght of the sling is equal to 100,25% of the EWL or 99,75% of the EWL, in total there are 16 different options, that the code loop througs all. -
Determine the start hook point
Because of the different lengths of the slings, the start of the hook point is different from the original. See the next chapter for a detailed explanation of the start of the hook point. -
Determine the number of slack slings
This is based on the distance between the lift points and the length of the slings with strain. -
Determine Fx, Fy, and Fz forces in hook
Fx and Fy are equal to zero. The Fz force depends on which iteration the "Loop skew load is" -
Checking if there are more than 2 slings tight:
- When there are 2 slings tight, this means that the hook is on the diagonal line of those two points. So the forces in the slings/ displacement of the hook can be determined using the 2d stiffness method.
- When there are 3/4 slings tight, the force in the slings/ displacement of the hook can be solved using the 3d stiffness method.
-
Results 2d/3d stifnes method
- Determine the new position of the hook, bases on the displacment of the hook and the position of the hook in the last iteration
- Determine total force in slings
- Determine total strain in slings
- Determine total force in hook, bases on the forces in slings and the angles of the slings
-
Checking if the total load is greater than the the force in z-direction, if this not the case steps 5,6,7 and 8 are done again, until the total force in z-direction is equal to the force of the lifted object. When the force is greater or equal the results are stored in a dictionary.
-
Checking if "Loop options short/long slings" had done all its 16 different combinations, if this is not the case steps 3 t/m 9 will be done again.
-
Determine the max skew load factor of each sling. Also, determine what the displacement of the hook/force in slings was with the max skew load factor and store these in a CSV file
The calculatinos to determine what the force in the slings are and the displacment of the hook are described in more detail in: Matrix Analysis of structure, second edition
Because of the different lengths, the start of the hook point is different than the original hook point. See below the flowchart, there has been an assumption made that the slings can not have any strain( no forces), when the forces in the hook are not equal to zero. This is the case when there is one rope tight, and the rope is not directly under the hook. The second case is when there are two tight and the hook lays not on the diagonal of the two liftings points.
- Determine the z-positon of the hook, this point is the first point when a cable is tight, it is determined with the following code, see code snippet below:
z_hook = []
for i in range(4):
# Determine distance between x and y points
x_dist = Lifting_points[i][0]-Hook_point[0]
y_dist = Lifting_points[i][1]-Hook_point[1]
# Z distance between lift point and hook point:
z_dist = side_3d_line(Lslings[i], x_dist, y_dist)
# Z_hook height:
Z_hook_height = z_dist+Lifting_points[i][2]
z_hook.append(Z_hook_height)
Hook_point[2] = min(z_hook)+0.000001
- Determine the number of slack slings
This is based on the distance between the lift points and the length of the slings with strain.
The hook will move to the lifting point of the tight sling, until the hook is right above the lifting point.
- Determine the displacement vector and delta hook
- Determine the new position of the hook
- Determine the number of tight slings
- If the number of tight slings is equal to 1, determine the new position of the hook otherwise break the loop.
When there are two slings tight, the hook will move to the diagonal line of those two lifting points:
- Radius line
- Determine the radius line(is the line which the hook will folow so that the two slings will have a constant length)
- Determine the minimal angle of the radius line with the z-axes(ymin)
- Determine the angle with the z-axes of the radius line
- Determine position hook
- Determine the number of tight slings
If there are number of slack slings is not changed and the radius line is perpendicular to the diagonal line, the hook lays on the diagonal line and it is two point lift
If there is one or two slack pulled tight it is a 3/ 4 points lift
When there are made many more extensions to the app and the app gets slow it is recommended to change the structure of the app in such a way that when a parameters is changed not all calculations in the communcation class have to be done. For now the app is still fast enough so it is not necessary to change the structure of the app.