dataesr/scientific-paragraphs-categorization huggingface dataset:
• Creation of a database of collisions with direct calculations. • Development of surrogate models for damage dimensions employing three different techniques: multiple linear regressions, neural network, and forest tree. • Comparison of the three regression strategies for real-time application. To address the aforementioned points, the paper has been structured as follows. After a short introduction on the state-of-the-art in risk assessment for passenger ships, Section 3 describes the flooding risk assessment in real-time for onboard applications. Section 4 details the crash analyses with the super-element method, with a focus on the software SHARP  (Le Sourne et al. , 2012). Section 5 demonstrates the process and methods adopted to generate the database of collisions, and Section 6 describes the methodology employed to develop the surrogate models for damage dimensions.
In fact, according to the general diagram provided in Fig. 1 , the input data and associated uncertainties enter the damage model, which estimates the damage dimensions. Therefore, with the input being formed by distributions (due to uncertainties modelling), the damage output is also composed of distributions. Subsequently, the outputs of the damage model provide input for the PLL evaluation. Following a Level-2. 1 model, the PLL is evaluated in two steps; first, the TTC is estimated from a surrogate model generated by a database of time-domain simulations composed of critical flooding scenarios for the struck ship  (Mauro et al. , 2022a (Mauro et al. , , 2022b)). Then, equation (  4 ) is applied to each member of the TTC distribution generated by the survivability model, which means obtaining a PLL distribution.
The final real-time PLL value is then determined as a Quasi-Monte Carlo integration process on a sample of input values. Then the PLL results from the following integration formula: PLL ≈ 1 N QMC ∑ NQMC i=1 PLL i (x Di , V Ti , α ci ) (6) where x D is the longitudinal position of the breach centre, V T is the target ship speed, α c is the collision angle and N QMC is the number of quasirandom samples. The present work focuses on the damage model and its generation through direct collision simulations, obtaining a data source for the development of a fast surrogate model for real-time calculations. Therefore, the characteristics of the model are discussed in the following sections, together with the description of the crash analysis tool employed to develop the damages database. The description of the process is supported by examples on a reference ship described hereafter.
Reference ship A reference case is provided, that of a sample cruise vessel to describe the novel approach for database generation employing direct crash analyses and real-time damage dimensions estimation. This reference ship has been used during benchmarking activities in project FLARE  (Kim et al. , 2022)  but was already employed during the FLOODSTAND (  2012 ) project  (Luhmann, 2009). Table  2  provides the main particulars of the ship, while Fig. 2  shows its general arrangement.
Crash analyses with super-elements method Crash analyses can be handled with different approximations, starting from high-fidelity methods like FEM simulations down to simple empirical formulations. As a matter of fact, the higher the accuracy is, the longer the computational demand becomes. Therefore, aiming at performing a very large number of calculations, the right balance between accuracy and computational effort needs to be found. To this end, a suitable solution is given by the super-elements method. Here, the computational method is briefly discussed together with the resulting damage model that can be used for the generation of a damage breach database.
, 2001) , where the hydrodynamic characteristics of the ship are obtained from the Bureau Veritas seakeeping analysis code Hydrostar  (BV, 2019). By employing such assumptions and codes, software SHARP is capable of performing fast collision simulations with an acceptable level of accuracy, reconfirmed by a recent benchmarking study against FEM codes predictions  (Kim et al. , 2022). Fig. 3  shows a view of the super-element model employed for the calculation in SHARP.
5  highlights the difference between SOLAS/eSAFE and box-shaped damages. When direct crash analyses are carried out to simulate ship-to-ship collision, it is possible to determine the effective shape of the breach once FEM analyses are used. However, as this study is based on the employment of the super-elements method implemented in SHARP, such a detailed definition of the breach cannot be achieved. This is not a limitation, as the crash analyses should produce a damage characterisation easily readable by flooding analysis tools, which, most likely, employ a box-shaped damage definition. Then, the software SHARP can estimate the breach's main dimensions necessary to define box-shaped damages. More specifically, L D , z LL and z UP are evaluated exactly as per SOLAS/eSAFE assumptions, and B D is considered as the maximum penetration along the breach length.
Damage database generation The damage model for a real-time risk assessment should be based on a database of direct calculations composed of outputs from crash analyses. As building a database requires the execution of a large number of simulations, the above-described method of super-elements implemented in the software SHARP is a viable solution to provide a damage characterisation easily useable for survivability calculations. In fact, it is necessary to perform a wide set of preliminary calculations in such a way as to obtain a global database, suitable to have a sufficiently accurate description of the potential damages that may occur in a specific operational area. To define the database it is necessary to establish which are the potential striking ships (i. e. , the targets) to be used in the crash simulations.
Here, in the applied example, a set of 11 potential striking ships has been used, being representative of the worldwide fleet, as indicated by a dedicated study on crashworthiness  (Conti and Hirdaris, 2020). Besides, the specific inputs of SHARP software should be considered, providing suitable inputs for the following set of data. • Target ship initial surge velocity V strik • Ship initial surge velocity V s • Longitudinal impact position (i. e. the longitudinal position of the damage centre x D ) • Collision angle α c • Target ship draught T strik • Ship draught T struk As a result, it is mandatory to follow a path aiming at saving computational time while granting a sufficient level of coverage for the damage-breach space. To this end, the design of experiments (DOE) is a suitable way to reduce the amount of observations needed to assess the variation of multiple dependent variables from independent ones.
In the present approach, a hybrid strategy has been followed considering the peculiarities of the independent variables to use and the physical necessities of the collision model employed for the direct crash  calculations. According to the calculation assumption of software SHARP, the ship structure is considered symmetric concerning the longitudinal plane. Furthermore, early studies of database development performed with SHARP software were related to a collision in a fixed point x D amidships, stratifying the other variables  (Conti et al. , 2022). However, the development of the collision database targets the whole ship length, which requires the adoption of a different strategy to select locations, as the presence of longitudinal bulkheads may affect the choice of specific locations or affect the distribution of results.
, 2022). The number of calculations needed to build a sufficiently dense database is a function of the vessel and operational conditions. The present paper does not cover this specific topic that needs a dedicated study for further enhancement of the proposed methodology. Applying the above-mentioned strategy for the reference ship, the following set of parameters has been selected to generate the hybrid space of the collision database. • Target type: 11 ships. • Target V strik : stratified in [2,4,6,8,10] m/s. • Ship V S : constant 0 m/s. • Longitudinal impact position x D : 500 quasi-random samples in [0. 2L PP ;0. 8L PP ]. • Collision angle α c : 500 quasi-random samples in [20; 90]. • Target ship draught T strik : stratified in 3 draughts • Ship draught T struk : stratified in 3 draughts.
Calculation results The results exported from SHARP are limited to the geometrical characteristics of the damage, which means the length L D , the penetration B D and the vertical limits z LL and z UL. For the case of collisions, as mentioned earlier, the geometrical model of the damage is given by a box having two faces parallel to the waterline, two faces parallel to the transversal plane and two faces following the longitudinal shape of the calculation draught waterline. Also within the provided code limitations, 295 scenarios end with computational errors, with a total of 5205 successful cases subdivided as follows: 486 for Target#01, 495 for Target#02, 491 for Target#03, 482 for Target#04, 478 for Target#05, 478 for Target#06, 410 for Target#07, 460 for Target#08, 493 for Target#09, 442 for Target#10 and 490 for Target#11.
More specifically, a complete 4th-order polynomial has been used as a starting model (except for T strik and T struk with 2 as maximum order), removing the variables having a p-value associated with F-statistic greater than 0. 1. • Neural networks: for these models use has been made of the training algorithm available in MATLAB, optimising the network structure for the best reproduction of the initial data. • Forest tree: for these models use has been made of the fitting algorithm available in MATLAB, optimising the tree structure for the best reproduction of the initial data. The analysis of the goodness of fit of the three models has been checked using the mean squared error MSE and the coefficient of determination R 2 , having the following forms:  R 2 = 1 - ∑ n i=1 ( y i -y * i ) 2 ∑ n i=1 (y i -y) 2 (8) where y i are the observed values, y i * are the predicted values, ў is the mean of the observed values, and n is the number of observed values.
Ship-specific models As a first attempt to determine a surrogate model for ship dimensions, use has been made of the single subpopulation of damages Fig. 10. Damage dimensions surrogate models, observed vs predicted for Ship#06. generated for each specific striking ship. For this specific case, the dependent and independent variables are the same as the construction of the database, therefore each of the damage characteristics L D , B D , z LL and H D is a function of x D , V strik , α c , T strik and T struk. The results of the regression and training analyses are reported in Tables 4-7 for the three analysed surrogate model types. The tables report the R 2 values for each quantity related to a specific striking ship. Besides, an indication of the complexity of the surrogate model is reported, giving the total number of regression coefficients for the multiple linear regression, the number and size of the layers of the optimum fit neural network, and the number of single trees used in the optimal forest tree.
Conclusions In the present study, first-principles direct crash analysis is employed to generate a surrogate model of breaches to be used in a real-time onboard risk assessment for ship-to-ship collisions. The application of Super-Element methods available in the SHARP software allows for generating a large number of scenarios in a reasonable time, enabling the setting up of a suitable database of breach dimensions. The present explorative study shows that with an initial population of about 4400 damages, the best fitting is given by forest trees. However, for simplicity of implementation in a real-time onboard risk assessment also a model based on multiple linear regression could be used. Of course, by increasing the number of the initial samples, the quality of the surrogate models may increase, not necessarily by increasing the samples of the DOE but more likely by increasing the number of striking ships to have more detailed coverage of the possible damage space.
Characterization of the Implant Using an X-ray Computed Tomography (XCT) System X-ray computed tomography (XCT) imaging was conducted at BAM with an industrial General Electric (GE) phoenix v|tome|x L 300/180 cone beam XCT system. This system includes a 300 kV microfocus X-ray tube as well as a 180 kV high-resolution nanofocus X-ray tube. The entire system is mounted on a granite-base 8-axes manipulator. The 180 kV high-resolution nanofocus X-ray tube was used for the scanning of the implants. This tube includes a transmission target made of tungsten on diamond with a minimum focal spot size of 1 μm. The custom bay system is also equipped with a GE 2048 × 2048 pixels (200 μm pitch) 14-bit amorphous silicon flat panel detector. The acquisitions as well as the reconstruction after the scans were performed with the phoenix datos|x GE software.
Analysis of the XCT Images Implementing a Machine Learning (ML) Segmentation The separation of the metal, bone, pores, osteoid tissue, and metallic grains from each other on the 3D images was carried out with the Ilastik program  [9]  and two custom in-house 2D UNets  [10] , forming a three-stage sequential ML process. Ilastik was used to annotate/generate efficiently the training data which were subsequently employed to train the UNets. This approach reduced considerably the time required to annotate the training labels compared to purely manual annotation. In other words, we accelerated the annotation of the required (by the UNets) training labels with the ML capabilities of Ilastik. Ilastik has been developed by the Ilastik team in Anna Kreshukʹs laboratory at the European Molecular Biology Laboratory (EMBL) in Heidelberg (Germany), and uses iterative ML algorithms to segment, classify, track and count the different image areas in 2D images and 3D stacks.
The pixel classification workflow in Ilastik assigns pixels to a group based on pixel/voxel features. These features can be selected by the user from a wide range of operations, for example smoothed pixel/voxel intensity, edge filters and texture descriptors. The user then selects some representative areas in the 3D image stack by color-coding the different areas to be segmented. Based on the image areas assigned to the classes by the user, the system interactively trains a random forest classifier. The predictions in the image data can be previewed so that the training can be improved interactively. The result is a unique classification of each pixel/voxel, into a previously defined class. These classifications can then be extracted. The main challenge with these XCT datasets is that it is very difficult to distinguish the bone and osteoid phases form each other based solely on grey values, as they appear very similar.
The osteoid phase appears typically slightly darker compared to the bone phase due to its lower density. However, the variation of contrast arising from beam hardening within the XCT datasets, can result in certain regions where the bone phase appears darker compared to the osteoid phase located at a different region (i. e. regions in different images within the 3D stack, or different locations within the same image). An example of this is shown in Figure  6. The complete segmentation of the datasets with Ilastik could had been possible, but with a lot more (manual) effort to account for all deviations across all regions. Our three-stage ML segmentation method accelerated the whole process by overcoming the above limitations. Our training strategy was the following: Firstly, we conditioned the five XCT datasets (labeled: 1382, 1384, 1385, 1386, and 1387) with a Non-Local-Means (NLM) filter  [11]  (parameters: sigma = 2, smoothing_factor = 1) to reduce noise.
Secondly, we extracted from dataset 1385 eleven random images (4+1 along xy plane, 2 along xz plane, and two along yz plane, (xy, xz, and yz planes as shown in Figure  7 ). Ilastik was employed to annotate the various phases/labels only within these eleven images (metal, bone, pores, osteoid tissue, and metallic grains) which then served as the training/validation/testing data for the UNets. The extra (+1) image from the xy plane was reserved only for testing the final segmentation accuracy (i. e. , training/validation: ten image pairs, testing: one image pair). Thirdly, to increase the number of training/validation data, we randomly mirrored/rotated the ten images to a total of 2000 image pairs (input images and ground truth labels), of which 1800 image pairs (90%) were used as training data, and 200 image pairs (10%) were used as validation data.
To improve generalization (i. e. to distinguish the similar bone and osteoid phases better during segmentation), we introduced to the training/validation datasets random brightness and contrast augmentations (+/-10%) in random order and intensity, moderate random Gaussian noise (0 -8 in 8-bit grayscale range: 0 -255), and random Gaussian blur (random sigma: 0 -1). This approach has been proven by Tsamos et al. [12]  to improve considerably the segmentation accuracy of different phases in XCT scans with overlapping grey levels. To further improve the segmentation accuracy, the training of the UNets was undertaken in two stages with a different UNet in each stage. The first UNet was trained to segment the various phases while treating the bone and osteoid phases as a single phase (i. e. 5 phases: metal, pores, metallic grains, bone/osteoid combined, and background).
9, beta2 = 0. 999, updated every iteration), with an input batch size of 8, and random shuffling for the training dataset on each epoch. The learning rate was updated exponentially on every epoch with a learning rate multiplier LRM = 0. 95, and we trained for a total of 300 epochs with Categorical Entropy Loss. The decisive (learnable/trainable) parameters within the UNets architectures were adopted from the epoch that minimized the validation error. Based on the reserved testing image, we report a global accuracy Dice score of 85%. Our forwarding strategy was the following: We sliced the NLM conditioned XCT datasets/stacks in 2D images along all three planes (i. e. xy, xz, and yz planes) and, for each plane, we applied four rotations (0°, 90°, 180°, and 270°). Thus, this resulted in 12 different sets of images (12 different views).
Each set was forwarded through the first (trained) UNet, resulting in 12×5 (5 possible phases for the first UNet) probability map sets. These probability map sets were rotated back to 0° and assembled back into 3D stacks according to the plane direction that were initially sliced, resulting in 12×5 probability map 3D stacks. Finally, the probability stacks were summed together according to their respective phase probability group, resulting in 5 probability stacks for the 5 phases. The final classification (i. e. assigned class/label: metal, pores, metallic grains, bone/osteoid combined, or background), was assigned based on the highest phase probability across all 5 probability stacks for each voxel. Based on this segmentation (i. e. from the first UNet), the grey levels of regions (voxels) in the XCT datasets that were segmented/classified as: metal, pores, and metallic grains were nulled to appear as background.
Next, a similar "multi-view" slicing of these datasets was performed before being fed into the second UNet. The assembly and final classification procedure was exactly the same as in the case of the first UNet (but this time with 3 probability stacks for the 3 phases: bone, osteoid, or background). Finally, we maintained the: metal, pores, metallic grains, and background assigned labels from the first UNet segmentation, and the: bone and osteoid labels from the second UNet segmentation to compose the concluding segmentation (Figure  9 ). The osseointegration process of titanium (Ti) implants in the body begins with the oxidation of Ti on the implant periphery by biological fluids (blood and lymph). This oxidation results in the formation of a TiO2 layer. This step is followed by the formation of a calcified (but not ossified) layer, of thickness about a few nanometers.
We present "Verified JavaBIP", a tool set for the verification of JavaBIP models. A JavaBIP model is a Java program where classes are considered as components, their behaviour described by finite state machine and synchronization annotations. While JavaBIP guarantees execution progresses according to the indicated state machine, it does not guarantee properties of the data exchanged between components. It also does not provide verification support to check whether the behaviour of the resulting concurrent program is as (safe as) expected. This paper addresses this by extending the JavaBIP engine with run-time verification support, and by extending the program verifier VerCors to verify JavaBIP models deductively. These two techniques complement each other: feedback from run-time verification allows quicker prototyping of contracts, and deductive verification can reduce the overhead of run-time verification.
A limitation of the JavaBIP approach is that it does not guarantee that these assumptions hold. This paper proposes a joint extension of JavaBIP and VerCors  [10]  providing such guarantees about the implementation statically and at run time. VerCors  [10]  is a state-of-the-art deductive program verification tool for concurrent programs. It verifies programs, written in e. g. Java, using permissionbased separation logic  [3]. This logic is an extension of Hoare logic that allows one to specify properties using contract annotations. These contract annotations include permissions, pre-and postconditions and loop invariants. VerCors automatically verifies programs with contract annotations. To verify JavaBIP models, we (i) extend JavaBIP annotations to include verification annotations, and (ii) adapt VerCors to support JavaBIP annotations.
VerCors transforms the verification annotations and JavaBIP models into contract annotations, leveraging their structure as specified by the FSM annotations and the glue. For some programs VerCors requires extra contract annotations, e. g. when complicated loops are involved. To enable properties to be analysed when not all necessary annotations are added yet, we extend the JavaBIP engine with support for run-time verification. During a run of the program, the verification annotations are checked for that specific program execution. The run-time verification support is set up in such a way that it ignores any verification annotations that were already statically verified, reducing the overhead of run-time verification. This paper presents the use of deductive and run-time verification in Verified JavaBIP to prove assumptions made on the JavaBIP models.
@Guard declares a named boolean function, whose result indicates if a transition is enabled. @Data either declares outgoing data of a getter method, or, incoming data via a method parameter. Note that the example does not specify when ports are activated. This is specified as glue, separately from the JavaBIP component  [9]. We added component invariants and state predicates to Verified JavaBIP. These are declared using the following annotations: @Invariant(expr) for a property that must hold after construction of the component and before and after executing a transition, and @StatePredicate(state, expr) for property that must hold when entering the state, and is assumed to hold when departing from the state. Furthermore, Verified JavaBIP includes pre-and postconditions as part of the @Transition annotation.