BIM-Enabled Two-Phase Optimization Framework for Automated Masonry Layout Efficiency

Abstract

Masonry construction remains labor-intensive, with current block placement predominantly dependent on workers’ empirical knowledge. Lack of systematic cutting plans induces substantial material waste and rework, adversely affecting sustainability. We propose a two-phase optimization framework to automate and enhance masonry block arrangement efficiency. Phase 1 decomposes masonry structures into optimizable subregions by geometric features, documenting each region’s geometry and position to generate optimization datasets. Phase 2 implements a computational module using the Social Network Search (SNS) algorithm to optimize subregion layouts, recording post-optimization block coordinates and dimensions. Finally, it materializes layout configurations and generates block quantity schedules to provide precise material demand data. An integrated prototype system was implemented in four specialized block arrangement scenarios and one building case study, validating both functionality and efficiency.

1. Introduction

Sustainable development and intelligent design are gaining prominence in the Architecture, Engineering, and Construction (AEC) industry [1,2,3,4]. Masonry remains among the most prevalent global structural systems [5,6]. Masonry construction relies on empirical knowledge for unit cutting and placement [7]. This experience-based approach generates significant material waste and rework. Traditional masonry demands highly skilled labor to ensure consistent quality. These labor-intensive processes incur substantial costs. The AEC industry faces an acute skilled labor shortage [8,9]. Diminishing skilled labor escalates construction errors, exacerbating raw material waste from suboptimal cutting.

Waste bricks comprise 30–40% of masonry construction and demolition debris. Few intact units are reusable, while residual waste bricks predominantly undergo landfilling. Limited landfill space availability causes waste bricks to consume significant land resources. Disposal also incurs costs for landfilling and transportation, elevating project expenditures [10]. Brick production requires substantial coal combustion, emitting significant airborne pollutants. Consequently, brick waste represents both embodied energy loss and environmental degradation [11].

Minimizing brick waste across the building life cycle is crucial to reduce project costs and environmental burdens [12,13]. Rigorous block arrangement planning during design minimizes on-site cutting waste and rework. Non-modular wall dimensions necessitate adaptive brick cutting, yet optimized layout designs can substantially reduce such waste. Empirical studies quantify cutting waste at 16.29% of masonry costs, with layout optimization reducing waste costs by 6.59% [14]. Suboptimal planning decisions generate significant construction waste and demolition waste. Consequently, meticulous pre-construction design effectively reduces material waste [15,16].

In current design practice, detailed masonry layout design is typically manually drafted by designers using Computer-Aided Design (CAD) software [17]. Designers plan block arrangements according to industry protocols and annotate dimensional and positional details on construction drawings. This approach suffers from three critical limitations:

Manual calculation burdens: Brick dimensions and positions require laborious manual computation, rendering the layout process time-intensive and error-prone, thereby causing substantial designer frustration [18];

2D representation constraints: Two-dimensional drawings fail to accurately visualize complex joint details, hindering effective on-site construction guidance;

Imprecise quantity estimation: Block quantities can only be approximated via volume ratios between walls and individual units, preventing precise procurement and usage data tracking.

Consequently, the absence of efficient design assistive methods perpetuates block arrangement design as a labor-intensive undertaking.

Since the early 21st century, the construction industry has undergone significant digital transformation through emerging technologies like Building Information Modeling (BIM), mixed reality, and digital twins [19,20]. Among these, BIM has proven particularly effective for reducing project costs and enhancing coordination [21]. BIM enables digital modeling of complex structures with multidimensional attributes (e.g., thermal properties, cost data), while programmatic scripting facilitates data extraction for algorithmic optimization [22]. BIM-facilitated automation reduces design errors and material waste, thereby minimizing on-site errors and lowering rework probability and construction waste generation. BIM implementations have advanced material design, construction emissions mitigation, site management, and supply chain optimization—collectively targeting material waste reduction in engineering practice [23,24,25,26,27].

As BIM technology evolves, researchers have attempted its adaptation to masonry structures. Some scholars proposed using drones to replace bricklayers for automated construction based on BIM models, thereby reducing labor dependency. However, substantial manual preprocessing remains required for model refinement due to the lack of precise design-support methods [28]. Addressing inefficient manual modeling, A. Monteiro et al. [29] utilized BIM’s built-in functions to automate block quantity calculations through parametric arrays, yet this approach fails to accommodate non-modular wall layouts—requiring manual adjustments for cut units. Moreover, excessive array operations cause BIM software lag, rendering it impractical for large-scale masonry.

Researchers also explored BIM-integrated solutions. Sharif et al. [30] developed a masonry unit database for digital representation and information exchange, establishing foundational data interoperability. Cavieres et al. [31] theorized a computational representation method involving geometric decomposition of masonry components into specialized zones for selective detailing. Given the complexity of non-modular masonry design, algorithmic solutions emerged. Tarek Zaki et al. [32] implemented parametric assembly algorithms to generate virtual BIM models for non-modular walls, but these models lacked layout granularity. C. Xu et al. [33] created a computational module using Neighbor Field Optimization to adjust block dimensions and joint thicknesses, though optimized results were confined to single walls by overlooking boundary conditions. J. Liu et al. [17] proposed a two-step memetic algorithm for multi-scale wall layouts with visualizations, yet wall junctions still failed to form structurally sound connections. Collectively, existing work achieves non-modular wall layouts but remains limited to isolated rectangular walls, neglecting critical inter-wall junction resolutions.

This study develops a two-phase systematic framework from a holistic masonry optimization perspective. The framework rapidly generates rational structural layouts while ensuring robust structural performance and compliance with architectural aesthetics. Its core objective is to benchmark masonry construction standards while accommodating on-site constraints, thereby reducing material wastage and preventing unnecessary time expenditures. The approach demonstrates dual advantages: enhanced applicability through standardized brick layout at wall junctions, and intelligent cutting pattern optimization that minimizes brick loss through a dedicated algorithm.

The paper is structured as follows: Section 2 introduces masonry layout specifications and adopted strategic principles.

Section 3 elaborates on the framework integrating BIM-API with Social Network Search (SNS).

Section 4 validates framework feasibility via four specialized block arrangement scenarios and full-scale architectural case studies.

2. Preliminary

This section introduces two conventional masonry construction methods as research subjects, while establishing standardized joint detailing protocols for diverse wall junctions and coordinated spatial arrangement strategies for non-modular walls. These serve as reference templates for subsequent architectural software development, ensuring compliance with practical constructability requirements.

2.1. Masonry Requirements

As shown in Figure 1, masonry units (MUs) represent the fundamental components of masonry structures. Fabricated from quasi-brittle materials (e.g., natural stone, fired/unfired bricks), MUs bond through mortar joints to form walls [34]. In masonry walls:

• Bricks with long edges parallel to the wall face are stretchers;
• Those perpendicularly oriented are headers.

Each horizontally layered row of MUs defines a course, while mortar joints between courses and adjacent units are designated horizontal joints and vertical joints, respectively [29]. Mortar joints must maintain geometric regularity to ensure uniform force transfer paths, thereby preventing localized stress concentrations and enhancing structural stability. Joint thickness requires precise control: excessive thickness compromises bonding integrity, whereas insufficient thickness diminishes strain accommodation capacity, impairing stress and load redistribution [35].

According to China’s Code for Construction of Masonry Structures (GB 50924-2014), mortar joint thickness should be maintained at 10 mm with a tolerance of ±2 mm (minimum 8 mm, maximum 12 mm) for both horizontal and vertical joints. Vertical joints between upper and lower courses must be staggered to achieve required lap ratios. Proper lap ratios enhance structural bearing capacity by distributing loads uniformly across units, with regional minimum requirements as follows: ≥1/3 unit length in China, ≥1/4 unit height per US ACI 530, and ≥2/5 unit length under Eurocode 6. To minimize cutting waste and ensure aesthetic compliance, full-sized units should be prioritized during construction. Simultaneously, the variety of unit dimensions within any single wall should be minimized to improve construction efficiency. Constructed dimensions must conform to design specifications: horizontally, the built length shall match the wall length without deviation; vertically, the cumulative course height shall align with wall height. Units must not exceed wall boundaries. US and EU standards share identical requirements with China for all criteria except joint thickness and lap ratios, as formally tabulated in

Table 1. Requirements for laying masonry walls in China, the United States, and Europe.

Layout Requirements	China	US	EU
Grout thickness	8–12 mm	6.4–9.5 mm	6–15 mm
Lapping rate	1/3	1/4	2/5
Priority of block sizes	Whole brick priority, with the variety of cut block sizes being minimized
Boundary constraints	The length and height of the masonry wall after laying should be consistent with the design requirements

.

2.2. Placement Strategy

In masonry construction, interconnected walls form connection zones, typically at corners. These wall connection zones are geometrically classified as L-shaped, T-shaped, or cross-shaped. Detailing at masonry connection nodes critically influences structural mechanical properties. Orthogonal wall toothing should exhibit high compatibility, with mortar joint dimensions strictly controlled to match adjacent sections. As critical bonding mechanisms, connection joints integrate walls into effective structural units. Additionally, masonry units at joints must satisfy minimum overlap ratios per Table 1 specifications.

The quantity of MUs in masonry structures, combined with integrated global geometries and localized bonding patterns, substantially complicates layout design. Direct full-structure optimization increases computational dimensionality, necessitating geometric decomposition for regional subdivision. Inter-wall junction design functions as the key criterion for segmenting Masonry Subsystems. These junctions require rule-based configurations to ensure effective inter-unit connectivity. Specialized geometric constraints at junctions achieve mechanically interlocking connections.

As shown in Figure 2, each masonry wall comprises two terminal joints and a continuous wall segment. Terminal joints are classified into four typologies:

• Cross-joints: Connect four orthogonally intersecting walls;
• T-joints: Interconnect three walls in T-configurations;
• L-joints: Connect two perpendicular walls at right-angle corners;
• Boundary joints: Terminate free wall ends while maintaining foundation vertical alignment.

As structural connectors, these joints integrate discrete regions into unified systems. Their geometry must satisfy three constraints:

• Fixed transverse layout per course;
• Mandatory connection to coordination units;
• Staggered lap lengths between consecutive courses.

Prioritizing terminal joint block arrangements reduces masonry layout optimization from 3D to 2D space. Constrained terminal joints shift optimization focus to cutting/layout schemes in continuous wall segments. The block layout problem is formulated as a two-dimensional bin packing problem. Geometric constraints partition structures into rectangular containers. Terminal joints function as pre-placed rectangular items occupying partial container areas. These items maintain fixed horizontal coordinates but vertically adjust per mortar joint thickness. Computational models and formulas for block optimization are detailed in Section 3.

During construction, masons typically lay bricks from both ends toward the center. When wall lengths deviate from modular dimensions, full bricks require cutting for layout completion. Minimum cutting thresholds apply:

• Lightweight blocks: unusable when cut below 1/4 total length;
• Aerated concrete blocks: typically discarded below 1/3 total length (non-mandatory).

To account for material-specific variations, the minimum usable length equals the brick’s width. Coordination bricks are incorporated per course with these characteristics to achieve rational non-modular layouts respecting length constraints:

• Position: Two units per course at both wall ends;
• Modular sizing: Length equals nominal brick width in modular walls;
• Non-modular adaptation: Maximum length equals full brick length in non-modular walls;
• Adaptive sizing: The adjustable length range of the bricks is $0\le cbl\le l_b-w_{\mathrm{b;}}$
• Course synchronization: Adjustments synchronized across coordination bricks in alternating courses.

This research adopts two fundamental bond patterns: Running Bond and English Bond. These configurations epitomize the opposing mechanical principles of continuous versus staggered joints, encompassing diverse construction complexities, wall thickness variations, and aesthetic expressions. Serving as the essential building blocks for comprehending advanced masonry techniques, they constitute the foundational lexicon of structural assembly—demonstrating exceptional representativeness and significant research value.

Coordination layout rules for both configurations are detailed below, each governed by two layout constraints distinguished by header brick arrangements in alternating courses. This systematic approach establishes fixed geometric constraints at wall terminals, facilitating subsequent subdivision for regional optimization.

As shown in Figure 3 in the Running Bond layout scenario, headers are placed at the ends of odd courses, while three-quarter bats are positioned at the ends of even courses. The bat length $l_{bat}^{,}=1/2\left(l_b+w_b\right)$ defines the first fundamental layout constraint. To enable interconnection between wall ends, the positions of headers and bats are swapped between odd and even courses under the first constraint, ensuring alignment of masonry joint zones in both elevation and profile views. Consequently, walls employing these two layout scenarios exhibit mutual perpendicularity in plan view.

In dual layout scenarios for the English Bond, the first configuration constrains three-quarter bats at odd-course ends and dual headers at even-course ends, with their combined length plus intermediate vertical joint thickness equaling full brick length; whereas the second configuration interchanges these odd/even course placements.

All aforementioned constraints share identical unit types: headers, three-quarter bats, full bricks, and coordination bricks. Coordination bricks are symmetrically placed at each course end within the layout plane, with an initial length equal to the brick width and a maximum length equal to the brick length.

3. Proposed Framework

A systematic framework achieves automated masonry block layout and optimization through two core phases:

• Phase 1: Information Acquisition;
• Phase 2: Layout Optimization.

The framework enables bidirectional data exchange between physical models and computational datasets via BIM APIs. It utilizes intelligent algorithms for decision support, decodes optimized data, and instantiates MUs. This process achieves automated masonry layout. Figure 4 illustrates the implementation workflow.

3.1. Information Collection Stage

3.1.1. BIM Software Selection

The framework’s data collection module implements C#-based secondary development utilizing Autodesk Revit’s API. Autodesk Revit provides a parametric modeling platform embedding relational logic between elements for coordinated change management [36]. However, masonry wall modeling remains complex and labor-intensive. Native Revit functionality proves insufficient for rapid, precise brick cutting and placement. Secondary development via Revit API resolves this limitation. The Revit API serves as a universal interface enabling C# application integration by users and developers. Revit-C# integration establishes efficient masonry layout optimization.

3.1.2. Extract Parametric Information from the BIM Model

The Information Collection Module extracts parametric masonry models from Revit, using BIM models as data carriers to acquire essential optimization parameters: wall dimensions, spatial coordinates, and unit specifications.

Revit API provides geometry processing capabilities. Wall geometric data resides in Solid entities. Figure 5 illustrates how wall geometry (Solid) is retrieved via the “Geometry” property. Solid entities contain all geometric faces and edges, enabling derivation of endpoints and directional vectors.

These attributes enable extraction of critical parameters: wall length, height, thickness, and reference point positions in Revit global coordinates. Geometric parameters serve as inputs for layout optimization, while spatial coordinates provide placement references.

3.2. Layout Optimization Stage

A computational module determines optimal brick layout parameters for subregion optimization. This process utilizes data collected by the information acquisition module, performing non-modular wall layout adjustments by:

• Modifying the quantity of full bricks;
• Cutting coordination bricks;
• Adjusting joint thicknesses.

The computation considers adaptability in both horizontal and vertical orientations while satisfying boundary constraints. An additional fitness function was implemented to minimize material waste from brick cutting.

3.2.1. Two-Dimensional Bin Packing Problem

This research models masonry wall layout optimization as a Two-Dimensional Bin Packing Problem (2D-BP). MUs represent rectangular items with defined dimensions, while wall models function as rectangular containers. Solutions must satisfy masonry specifications under standard 2D-BP constraints to maximize space utilization.

Placed MUs become obstacles for subsequent optimization, requiring:

Non-overlapping placement;

Edges parallel to container boundaries.

This 2D-BP solution yields masonry unit layout schemes. The 2D-BP extends the 1D bin packing problem geometrically. This NP-Hard problem packs item set $A=\left\{r_i\left(w_i,h_i\right)|i=\mathrm{1,2},\dots ,n\right\}$ into bins to maximize filled area under:

All edges parallel to bin boundaries without exceeding them;

Non-overlapping placement without rotation.

While MUs possess three-dimensional geometry, their thickness remains irrelevant to wall layout optimization. Consequently, masonry layout problems reduce to computationally complex two-dimensional optimization domains. To address the unique characteristics of masonry arrangements, this study employs a stratified layout approach (Figure 6) for solving the 2D bin packing problem.

Each container layer corresponds to a brick course in this methodology. The process operates through two sequential phases: initially packing rectangular items into horizontal layers, then progressively filling each layer to complete containers. This stratified strategy simultaneously satisfies masonry bonding requirements and reduces computational complexity.

3.2.2. Layout Model

To precisely position MUs, their 3D representations are abstracted into 2D models defining wall-relative positions. A Cartesian coordinate system is established on the wall substrate with origin at the bottom-left vertex: X-axis along the bottom edge (length L), Y-axis along the left edge (height H).

Per geometric principles, control points are defined at planar edge intersections: origin $A(X_A,Y_A)$, top-left vertex $B(X_B,Y_B)$, and bottom-right vertex $C(X_C,Y_C)$. Brick arrangements at wall terminals follow bonding patterns:

Running Bond: Three-quarter bats (odd courses) and headers (even courses);

English Bond: Dual parallel headers (odd courses) and three-quarter bats (even courses).

Control points are offset to locate coordination bricks:

• $A\to A^{\prime }(X_A^{\prime },Y_A^{\prime })$: Bottom-left coordination brick;
• $B\to B^{\prime }(X_B^{\prime },Y_B^{\prime })$: Top-left coordination brick;
• $C\to C^{\prime }(X_C^{\prime },Y_C^{\prime })$: Bottom-right coordination brick.

The resulting 3D coordinate system is illustrated in Figure 7.

3.2.3. Decision Variable

Masonry layout aims to integrate units and mortar into robust, stable structures while satisfying constraints governed by design standards, construction requirements, wall dimensions, bonding patterns, and unit sizes. Key decision variables for bonding methods are detailed below.

In masonry layouts, course height $H_c$ comprises unit height $H_u$ and horizontal joint thickness $H_j$. While bonding patterns vary, $H_u$ remains constant. Vertical layout optimization adjusts $H_j$ and course quantity $N_c$. All horizontal joints require uniform thickness adjustment within the range specified in Section 3.2.1 for mortar joint standards.

The horizontal joint thickness ${\chi }_1$ ranges between $8 \mathrm{m}\mathrm{m}\le {\chi }_1\le 12 \mathrm{m}\mathrm{m}$. The number of courses ${\chi }_2$ depends on the ratio of wall height Hw to brick height Hb, thus ${\chi }_2$ satisfies $0\le {\chi }_2\le int({\displaystyle \frac{H_w}{H_b}})$.

As brick wall layout is repetitive, optimization focuses solely on odd and even courses. Vertical joint thickness dl remains fixed at the optimal value. Coordination brick length ${\chi }_3$ ranges from brick width to length: $w_b\le {\chi }_3\le l_b$. The quantities of full bricks in odd/even courses $({\chi }_4{,\chi }_5)$ are determined by the ratio of wall length $l_w$ to brick length $L_b$. Since brick counts must be integers, ${\chi }_4{,\chi }_5\in [0,\mathit{int}({\displaystyle \frac{L_w}{L_b}})]\cap \mathsf{{\rm Z}}$.

Continuous variables in brick layout optimization are discretized via Gaussian rounding. Specifically, each variable yields two potential integer values after processing, with Gaussian operation selecting the nearest integer as defined by Formula (1).

$$X=\left\{\begin{array}{l}\left[x\right],0\le x-\left[x\right]<0.5\\ \left[x\right],0\le x-\left[x\right]<1\end{array}\right.$$

(1)

3.2.4. Fitness Function

Based on the problem’s objectives and constraints, a penalty function is constructed to form the vertical fitness function.

Odd-course layouts must satisfy wall length constraints, minimizing the distance between horizontally arranged brick length and wall length $L_w$. The corresponding penalty function $P_1$ is defined in Formula (5).

$$X_C^{\prime }=X_A^{\prime }+2\left(x_3+d_l\right)+x_4\left(l_b+d_l\right)-d_l$$

(2)

$$X_C=X_C^{\prime }+l_f$$

(3)

$$X_A^{\prime }=l_f$$

(4)

$$P_1(x)=\sqrt{(L_W-X_C{)}^2}$$

(5)

Even-course layouts must similarly satisfy wall length constraints, with penalty function $P_2$ given in Formula (7).

$$G=2l_f+2\left(x_3+d_l\right)+x_5\left(k_b+d_l\right)-d_l$$

(6)

$$P_2(x)=\sqrt{(L_W-G{)}^2}$$

(7)

Note: $k_b=l_b$ for Running Bond; $k_b=l_b$ for English Bond.

Brick layouts must comply with wall height constraints, minimizing the distance between vertically stacked brick height and wall height $H_w$. Penalty function $P_3$ is specified in Formula (10).

$$Y_B^{\prime }=Y_A^{\prime }+(h_w+x_1)x_2+x_1$$

(8)

$$Y_B^{\prime }=Y_A^{\prime }+x_1$$

(9)

$$P_3\left(x\right)=\sqrt{{\left(H_w-Y_B^{\prime }\right)}^2}$$

(10)

Material waste reduction requires minimizing course counts. Penalty function $P_4$ is defined in Formula (11).

$$P_4\left(x\right)=x_2$$

(11)

Joint thickness should approximate optimal thickness $l_j$. Penalty function $P_5$ is given in Formula (12).

$$P_5(x)=\sqrt{(x_1-l_j{)}^2}$$

(12)

The x-coordinates $X_A^{\prime }$, $X_B^{\prime }$, $X_C^{\prime }$ correspond to points $A^{\prime }$, $B^{\prime }$, $C^{\prime }$, while $Y_A^{\prime }$, $Y_B^{\prime }$, $Y_C^{\prime }$ denote their y-coordinates; $l_b$ is brick length, $w_b$ brick width, $h_w$ brick height, and $l_b^{\prime }$ three-quarter bat length. End brick length $l_f$ is configured as follows:

• Three-quarter bat ends: $l_f=l_b^{\prime }+d_l$;
• Dual-header ends: $l_f=2(w_b+dl)$;
• Single-header ends: $l_f=w_b+l_b^{\prime }+2d_l$.

For the vertical multi-objective model with inconsistent dimensions, Max-Min normalization (Formula (13)) eliminates dimensionality before constructing the fitness function.

Linear weighting of multi-objective problems into a single-objective formulation represents a prevalent approach in optimization methodologies. This study employs the linear weighting method to aggregate five objective functions P into a unified fitness function for masonry wall layout optimization, as formalized in Equation (14).

$$P{P}_i={\displaystyle \frac{P_i-\mathit{min}\left(P_i\right)}{\mathit{max}\left(P_i\right)-\mathit{min}\left(P_i\right)}}$$

(13)

$$MininzeF=\sum _{i=1}^5{{\omega }_{i}PP}_i\left(x\right)$$

(14)

$$\sum _{i=1}^5{\omega }_i=1$$

(15)

where ${\omega }_i>0$ denotes the weight coefficients.

Fifteen masonry engineering experts were invited to evaluate five criteria using the 1–9 importance scale. Their assessments were consolidated into judgment matrix C₁ (

Table 2. Judgment matrix C₁.

	Odd-Course Bond Pattern	Even-Course Bond Pattern	Longitudinal Bond Pattern	Course Count	Mortar Joint Thickness
Odd-Course Bond Pattern	1	1	3	7	5
Even-Course Bond Pattern	1	1	3	7	5
Longitudinal Bond Pattern	${\displaystyle \frac{1}{3}}$	${\displaystyle \frac{1}{3}}$	1	5	3
Course Count	${\displaystyle \frac{1}{7}}$	${\displaystyle \frac{1}{7}}$	${\displaystyle \frac{1}{5}}$	1	${\displaystyle \frac{1}{3}}$
Mortar Joint Thickness	${\displaystyle \frac{1}{5}}$	${\displaystyle \frac{1}{5}}$	${\displaystyle \frac{1}{3}}$	3	1

). The eigenvalue method yielded the weight vector ${\omega }_i$ = (0.3621, 0.3621, 0.1607, 0.0389, 0.0762), with consistency metrics R = 5.1361, CI = 0.0340, and CR = 0.0306. As CR < 0.1, matrix C₁ passes the consistency test.

3.2.5. Layout Solution for the SNS

This study addresses masonry wall layout optimization as a two-dimensional bin packing problem. Current solution approaches comprise three algorithmic categories: exact algorithms, heuristics, and metaheuristics. Exact algorithms guarantee optimal solutions but necessitate exhaustive searches across all configurations, becoming computationally prohibitive for large-scale masonry walls with high unit counts. Heuristic algorithms rapidly generate approximate solutions yet frequently converge to local optima with significant solution uncertainty [37]. Metaheuristics enhance heuristic methods by integrating stochastic processes with local search mechanisms, extending exploration from local to global optimization. For masonry layout problems, metaheuristics demonstrate enhanced computational efficiency.

The SNS algorithm is a novel metaheuristic optimization method that simulates human–social interactions [38]. In this paradigm, each user’s viewpoint represents a candidate solution, while social behaviors—imitation, dialogue, disputation, and innovation—function as algorithmic operators that continuously generate new solutions. Compared to conventional methods (

Table 3. A comparison of the SNS algorithm and traditional metaheuristic algorithms.

Comparison Dimension	Traditional Metaheuristic Algorithms	SNS Algorithm
Inspiration source	Natural phenomena (biological evolution, bird flocks)	Human social behavior
Operator design	Single dominant mechanism (e.g., crossover, velocity update)	Four-emotion collaborative mechanism with dynamic switching strategy
Exploration-exploitation balance	Reliance on fixed parameters (e.g., inertia weight)	Adaptive emotion selection without manual parameter tuning
Problem adaptability	Require problem-specific operator tuning	Naturally suited for high-dimensional, multimodal, dynamic optimization problems
Objective	Rapidly obtain locally feasible solutions	Globally approximate optimal solution
Search strategy	Local search lacking randomness	Global exploration + local exploitation
Generality	Dependence on problem characteristics	Strong generalization capability

), SNS demonstrates enhanced accuracy in solving large-scale masonry layout problems. It efficiently identifies near-optimal solutions for complex, high-volume unit arrangements through enhanced optimization efficiency and accelerated convergence [39].

In solving masonry wall layout problems, each solution set is randomly initialized within the search boundaries of five fundamental variables defined in Section 3.2.2 (Equation (16)). The masonry wall structure is modeled by solution vector $X_i=\{x_1,x_2,x_3,x_4,x_5\}$, where i denotes the i-th solution.

$$X_0=L_B+rand(U_B-L_B)$$

(16)

where $L_B$ is the lower bound, $U_B$ the upper bound, and rand a random number in [0,1].

During computation, new solutions are generated by operators corresponding to real-world social moods. SNS randomly selects an integer between 1 and 4 before updating solutions, with each integer representing a specific mood operator. Each solution stochastically adopts one operator to update its layout configuration.

(1) Imitation Behavior (Formula (17)): When influencers post new activities, most users imitate their behavior.

$$\left\{\begin{array}{l}{X}_{inew}=X_j+rand(-\mathrm{1,1})\ast R\\ R=rand\left(\mathrm{0,1}\right)\ast r\\ r=X_j-X_i\end{array}\right.$$

(17)

where i, j denote distinct users (i ≠ j), R is the influence level of user j, R represents popularity of user j, and $X_i$, $X_j$ are randomly selected conversational partners.

(2) Dialogue Behavior (Formula (18)): Users engage in virtual interactions to discuss topics.

$$\left\{\begin{array}{l}{X}_{inew}=X_k+R\\ R=rand\left(\mathrm{0,1}\right)\ast D\\ D=sign(f_i-f_j)(X_j-X_i)\end{array}\right.$$

(18)

where $X_k$ is a randomly chosen third user (k ≠ i ≠ j), R is the imitation effect, D is viewpoint divergence, and $f_i$, $f_j$ are fitness values of individuals i and j.

(3) Disputation Behavior (Formula (19)): Users defend their viewpoints while considering opposing perspectives.

$$\left\{\begin{array}{l}{X}_{inew}=X_i+rand\left(\mathrm{0,1}\right)\ast (M-AF\ast X_i)\\ M={\displaystyle \frac{{\sum }_r^{Nr}{X}_t}{N_r}}\\ AF=1+round\left(fand\right)\end{array}\right.$$

(19)

where M is the mean opinion in comment sections or fan communities, and AF (Approval Factor, 0 or 1) indicates agreement level.

(4) Innovation Behavior (Formula (20)): Novel viewpoints emerge by altering conceptual features.

$$\left\{\begin{array}{l}{X}_{i,new}^d=t\ast X_j^d+(1-t)\ast n_{new}^d\\ n_{new}^d=l{b}_d+ran{d}_1\ast (u{b}_d-l{b}_d)\\ t=ran{d}_2\end{array}\right.$$

(20)

where d is a randomly selected dimension, $r{and}_1$, ${rand}_2$∈ [0,1], and ${ub}_d$, ${lbd}_d$ are dimension bounds.

Based on the minimization principle of the objective function, if a newly generated solution outperforms the current solution, it replaces the current solution. The algorithm then checks termination conditions; if unmet, it proceeds to the next iteration until conditions are satisfied, outputting the optimal solution. The algorithm flow is shown in Figure 8.

4. Case Analysis and Discussion

This section verifies the effectiveness and practicality of the proposed framework through experimental validation. Section 4.1 details the experimental parameters, while Section 4.2 establishes three case studies: masonry corners with three geometric configurations, walls containing openings, and a full-scale architectural case to comprehensively test the methodology.

4.1. Experimental Configuration and Parameters

This study utilized Revit for BIM modeling, with automation implemented via C# API calls. Experiments employed standard cement bricks (190 mm × 90 mm × 40 mm), optimal joint thickness of 10 mm, following both Running Bond and English Bond patterns. Algorithm parameters included 50 initial users, 300 maximum iterations, and uniform 0.25 selection probabilities for imitation, dialogue, disputation, and innovation operators, with stochastic selection per iteration. Computations were executed on an Intel^® (Santa Clara, CA, USA) Core™ i7-10750H processor (2.60 GHz, 6 cores) with 16.0 GB RAM under Windows 10 64-bit OS.

4.2. Framework Test Case

4.2.1. Layout Experiment with Corner Areas Included

Case Study 1 investigated continuous walls with corner joints to validate subregion integration. Three joint typologies were evaluated:

• L-shaped corners (Type a);
• T-shaped corners (Type b);
• Cross-shaped corners (Type c).

Wall dimensions (

Table 4. Information about the wall in Case 1.

Walls	Corner Type	Length (mm)	Height (mm)
Wall 1	a	2000	2000
Wall 2	a	2300	2000
Wall 3	b	2600	2500
Wall 4	b	2900	2500
Wall 5	b	3200	2500
Wall 6	c	3500	3000
Wall 7	c	3800	3000
Wall 8	c	4100	3000
Wall 9	c	4400	3000

) varied within length ranges of 2000–4400 mm and height ranges of 2000–3000 mm. Each configuration underwent combinatorial connection testing to validate layout adaptability across joint types.

The original BIM model is shown in Figure 9. Based on wall connection types, Case (a) was divided into two computational regions, Case (b) into three regions, and Case (c) into four regions. The prototype system converted BIM geometric data into optimization inputs while recording wall position coordinates, automatically generating layout results. As demonstrated in Figure 10, brick arrangements under both Running Bond and English Bond patterns satisfied two critical criteria across all nine wall assemblies: strict adherence to staggered joint requirements within wall boundaries, and maintenance of staggered lap lengths at junction zones enabling structural continuity.

The system achieved non-modular layouts while ensuring structurally sound corner joint connections.

The production efficiency of the proposed framework was evaluated against time-consuming manual modeling. Each case was executed five times independently, with average runtimes recorded in

Table 5. Time spent on manual and program modeling.

Instance	Bond Type	Corner Type	Subregion Quantity	Program Modeling Time (s)	Manual Modeling Time (s)
a	Running Bond	L-shaped	2	15.4	223
	English Bond			15.5	285
b	Running Bond	T-shaped	3	19.5	377
	English Bond			20.3	553
c	Running Bond	Cross-shaped	4	25.2	512
	English Bond			27.5	871

. Since the SNS algorithm decomposes wall layouts into five key points (fixed-dimensional solution space), computational time remains unaffected by wall dimensions but scales with subregion count. Notably, English Bond layouts required marginally longer processing than Running Bond due to higher brick quantities, which increased Revit instance placement time.

Professional BIM engineers manually created Cases (a), (b), and (c) for benchmarking. Comparative analysis revealed two key advantages:

• 93% Time Reduction: Manual layout exceeded 5 min per case, while the framework achieved near-instant generation;
• Performance Optimization: Manual array operations caused model lag, whereas prototype-generated brick instances ensured seamless operation.

4.2.2. Layout Experiment Including Wall Openings

Case Study 2 examined walls with door/window openings, including:

• Instance (a): Wall length 4000 mm, height 3000 mm, containing a 1500 × 2100 mm door opening with bottom edge flush to wall base;
• Instance (b): Identical wall dimensions with a 1200 × 1300 mm window opening elevated 900 mm from the base.

The proposed framework automated layouts using vertical segmentation (Figure 11), dividing Instance (a) into three regions and Instance (b) into four. Final layouts (Figure 12) demonstrate that vertical partitioning—unlike Xu et al.’s horizontal approach—prevents vertical mortar joint misalignment at region interfaces [33]. By applying the layout strategy from Section 2.2, subregions combined seamlessly while maintaining opening dimensions identical to original BIM specifications.

4.2.3. Building Case

Case Study 3 analyzed an architectural case study of a residential building’s ground floor, characterized by complex architectural form and wall geometries with sufficient detail granularity. The 2D design drawings (Figure 13) feature walls of varying dimensions with 3000 mm free-standing height, incorporating L-shaped, T-shaped, and cross-shaped corners alongside door/window openings. The Revit-based 3D BIM model is shown in Figure 14.

The proposed framework generated masonry layouts by partitioning 23 walls into 44 subregions based on corner/opening configurations. Layout results (Figure 15) were automatically produced by the prototype system, exhibiting zero instances of vertical mortar joint misalignment or boundary-exceeding bricks. Furthermore, the framework incorporates real-world masonry standards and bricklaying practices, enhancing solution quality and practical applicability.

By utilizing the schedule function, precise brick quantity data for the building can be obtained to generate accurate procurement information. In practical projects, engineers typically estimate brick consumption through theoretical calculations using Formula (21).

$$N=\sum {\displaystyle \frac{S\ast K\ast r}{\left(Brl+d\right)\ast \left(Brh+d\right)}}$$

(21)

where S denotes the wall area requiring bricklaying, K is the coefficient determined by the ratio of wall thickness to brick thickness, $Brl$ represents the brick length used in the area, $Brh$ is the brick height dimension affecting consumption, d indicates mortar joint thickness, and r is the cutting loss coefficient for non-modular walls.

Calculation results for the residential case study indicate that Running Bond requires 22,008 bricks theoretically, while English Bond requires 44,016 bricks. The scheduling system prioritizes sourcing sub-90 mm bricks from cutting waste, with 90 mm half-bricks obtained by splitting full bricks. Actual consumption after optimization totals 21,604 bricks for Running Bond (1.87% reduction) and 43,067 bricks for English Bond (2.2% reduction). Compared to traditional estimation methods, the proposed framework not only provides precise procurement and cutting data but also effectively reduces material consumption. Procurement teams can utilize accurate brick quantities from schedules for purchasing, while construction crews and supervisors execute masonry works using optimized layouts adapted to actual site conditions.

5. Conclusions

This study proposes a BIM-based secondary development system for automated masonry layout, designed to efficiently complete masonry structural designs while preventing material waste and rework caused by improper on-site cutting. The system integrates professional knowledge of brick cutting, arrangement, and planning with computational algorithms, utilizing C# to call Revit API for optimized masonry layouts. Validation was performed through four specialized masonry zones and one architectural case study.

The research contributions are as follows:

(1)

The proposed optimization framework achieves standardized and aesthetically coherent brick layouts for individual walls, interconnected wall junctions, and openings (doors/windows) in common special sections;

(2)

Rapid parametric modeling of masonry walls significantly reduces repetitive tasks, improving modeling efficiency by over 93% compared to manual methods. All test cases generated masonry models within 30 s through instantiation of brick families;

(3)

By optimizing masonry wall layouts, the system rationally plans brick usage, reducing consumption by 1.87% (Running Bond) and 2.2% (English Bond) compared to conventional budgeting. It provides precise cutting specifications and procurement data;

(4)

Abstracting masonry layout into a 2D bin packing problem with domain-specific constraints, this work pioneers rectilinear wall optimization strategies and masonry layout models. This demonstrates practical engineering applications of 2D bin packing theory and offers solutions for tile, formwork, and curtain wall layouts;

(5)

The innovative integration of intelligent optimization algorithms with C# programming enables cross-platform collaboration, advancing civil engineering-computer science convergence and supporting intelligent construction transformation.

However, the developed automated masonry layout methodology exhibits the following limitations:

(1)

This study is currently limited to two common bond patterns (Running Bond and English Bond), rectilinear walls, and single-size MUs. Further research is required to optimize layouts incorporating diverse MUs, construction techniques, and wall geometries encountered in actual engineering practice;

(2)

The methodology adheres strictly to China’s masonry construction codes (GB 50924-2014), resulting in distinct regional characteristics. Subsequent research should extend this approach to accommodate international masonry standards;

(3)

The mathematical model prioritizes minimizing MU consumption and achieving uniform mortar joint thickness within code-compliant constraints derived from empirical construction practices. While the metaheuristic algorithm delivers near-optimal solutions within acceptable engineering tolerances, future work should integrate advanced computational strategies to pursue exact solutions for enhanced precision.