Create elements
create_elementsCreates new elements or spatial nodes and answers with the effect report (new revision); never changes an existing one (set_section, set_dimension, set_properties do; a bar set: reinforcement.replace). Several of one form (6 columns, a row of piles): one call with places, one revision, all or nothing, one type per series - not one call per element; the louvres or slats of a bay: one element, profile with repeat; columns, beams on a regular grid (IfcGrid if present): places, or one then copy_elements with n. Shape from the first of these that carries: a template (like), an outline, a path, a catalog section (section: HEA 200 with a height), or a class with dimensions. By class: outline IfcCovering, IfcPlate, IfcSlab; path IfcWall, IfcBeam, IfcMember, IfcPile (round or profile), pipes, ducts; section, dimensions, mesh and hull the other building elements; assembly a stair, railing, curtain wall or roof with its parts; a device a box with ports; a junction fitting joins three free segment ends; IfcGrid grid; IfcAlignment alignment. Every mandatory value must be named; nothing is invented. A type class (IfcDoorType ...) makes a type object: attributes Name and what the schema requires, no at; body optional: mesh or hull in type coordinates (origin 0,0,0), or like an element. Then like that type with at places occurrences; existing ones join by set_relation IsTypedBy. Scope first: a request that leaves the detail open (a house, a hall) and takes more than 10 new elements opens with one message before any write. Don't hold back: what a builder would need (envelope with its layers, openings with their fills, roof with its covering, interior, foundations, named systems) with sizes and materials, the LOD you propose (100, 200, 300; propose 300) and the open points. Then build the agreed items in full, naming any left out. Storeys, spaces, infra nodes, empty containers: get_guide topic create_building.
Tool call template
This tool declares no required parameters. Add optional parameters from the input schema as needed.
{
"id": 1,
"jsonrpc": "2.0",
"method": "tools/call",
"params": {
"arguments": {},
"name": "create_elements"
}
}Input Schema
| Name | Required | Description | Default |
|---|---|---|---|
| at | No | Element origin in m, not a corner: class with dimensions centres the profile on it and extrudes from it; like keeps the template offset; beside outline only z. Required except for the first IfcRoof, IfcStair or IfcElementAssembly of a model, which a bare class with ContainedInStructure puts at that storey origin. | |
| top | No | With outline instead of thickness: top z in world m per outline corner (sloped wall top, ramp); written as a mesh, a warped top as triangles (read_as names the diagonals). IfcSpace: its ceiling per corner, the prism to the highest top cut by one half space per sloped face | |
| grid | No | IfcGrid (class IfcGrid or left out): axes in grid m from at, x along ref_direction. spacing: axes at 0, s1, s1+s2 ..., tags left out 1, 2, 3 (u) and A, B, C (v), named in assumption; explicit: tag, from, to per axis. Beside it only ContainedInStructure and attributes Name, Description, ObjectType, PredefinedType (left out RECTANGULAR for spacing, NOTDEFINED explicit); any other field is refused field_not_for_grid. The report's grid: axes, grids per storey, assumption, index read back. Axes later: edit_grid | |
| hull | No | With class alone, like mesh: points [[x,y,z],...] in world m (type coordinates beside a type class), the body is their convex hull (coplanar faces merged, inner points dropped, counted in read_as) | |
| like | No | Template: an occurrence of the model, a type object (a new occurrence of it: a copy of its first occurrence mapping its body, any first one where it has no Body map; else it maps its one Body map, one at, unrotated), or {library, guid|name} from a catalog (copied once per file); a whole with parts: copy_elements. Beside a type class: an element whose body the new type copies | |
| mesh | No | With class alone: closed shells side by side, one face set; no at, dimensions, outline, path, section. Points within 1e-6 m are welded, inward faces turned (both counted in read_as); refused: an open shell, a shell inside another, or one facing inward beside one facing out. A gable wall: IfcWall with path and profile | |
| note | No | Your note, stored with the new revision | |
| path | No | Axis path, two points: IfcWall, IfcBeam, IfcMember (beside profile any building element; dimensions.radius alone: a round bar), IfcPile from its head to its toe with dimensions.radius or profile only (with section or like: at, the pile runs down from it); sets the length; two-point walls end square at their axis points, no mitre (two walls meeting at a corner overlap inside and leave the outer corner square open); with like a wall, beam or member template's section along it. A wall with dimensions.height beside a wall pattern or like: its type and layers, thickness from the layers or named; 3 or more points: one wall per leg, mitred and joined ATEND-ATSTART (IfcRelConnectsPathElements) at each inner point, corner_radius an arc wall there; layers: one usage for all. A run of IfcCableCarrierSegment, IfcCableSegment, IfcConveyorSegment, IfcDuctSegment, IfcPipeSegment: 2 or more points in flow order, dimensions {radius} or {width, height} (+ thickness: hollow) or profile, AssignedToGroups; one segment per leg, a bend at each inner point. Beside profile (any element) or section (IfcBeam, IfcMember) 3 or more points: ONE body swept along them, the section upright (v keeps up), a mitre at each corner without corner_radius | |
| port | No | A new IfcDistributionPort on an existing element (class IfcDistributionPort or left out; attributes Name only): placed on its body, linked to the one free port of another element within 1 mm whose flow joins (two or more, or an unset flow: none, named). Any other body is refused, never guessed | |
| along | No | Instead of path beside profile or section: one body along an IfcAlignment, section square to the tangent, v up; cant_rotation applied rolls it with the cant (not with roll_deg); across a ramp a closed ruled mesh of the profile corners, assumption cant_transition_ruled_mesh with spacing_m (no profile_voids: cant_ramp_with_voids). A changed section: one element per section. read_as names exact and approximated pieces, created[].assumption each rule with deviation_m | |
| class | No | IFC class when there is no template; IfcRoof, IfcStair, IfcStairFlight or IfcElementAssembly without body form, assembly or pattern: an empty container (parts join by Decomposes; an IfcStair takes IfcStairFlight, IfcSlab, IfcRailing; PredefinedType in attributes); components (IfcMechanicalFastener, IfcDiscreteAccessory ...) take dimensions like building elements | |
| joins | No | Junction fitting (IfcPipeFitting, IfcDuctFitting, IfcCableFitting ...) without like: a tee joining three free segment ends, any order. Port flows decide: a divide has Inlet (segment port SOURCE), Outlet1 straight on (same section), Outlet2 the branch; a merge Inlet1 straight on, Inlet2 the branch, Outlet. The branch leaves or joins the run flow at over 15 up to 90 deg, as the segments lie; no end straight on: a Y of equal round ends. Leave each run end room around the branch (a refusal names need_m). Place, body, ports and system come from the ends; PredefinedType JUNCTION. Free ends only: a run passing the branch is made as two runs meeting at it | |
| ports | No | Device (a class under IfcFlowTerminal, IfcFlowController, IfcFlowMovingDevice, IfcEnergyConversionDevice ..., IfcDistributionControlElement; IfcDistributionChamberElement) without like: with at (middle of the box underside), dimensions {length, width, height} and AssignedToGroups it is built as a marked box (source assumption, Moddl_Vorlage.Detaillierung = envelope). dimensions {radius, height} instead builds a cylinder, axis up (Moddl_Vorlage.Vorlage = envelope_cylinder). Each port on exactly one face (box face, cylinder mantle or cap), its z along the flow (SOURCE along the face normal, SINK against it); required for flow devices, optional for sensors and chambers | |
| layers | No | Without template, IfcCovering, IfcPlate, IfcSlab, IfcWall with dimensions.thickness: an IfcMaterialLayerSet in this order - a wall's first on the right of its path seen from its first point (each leg of a longer path; no corner_radius), its own body centred on it: the path is the reference line, written as its Axis where the file has one 3D model context (else read_as names the assumption); a slab's at its outline plane or bottom; read_as names each first side in world. The thicknesses sum to dimensions.thickness, else refused. Beside a pattern of the class too (pattern_ignored); no Material.Name beside it | |
| places | No | One element per entry, the form above: exactly one of at, path, outline (outline may take at for its bottom plane), the same in every entry; no path, outline, mesh above, at above only where every entry is an outline naming no at (their bottom plane); of spatial nodes only IfcSpace, each its own prism | |
| repeat | No | With profile and a straight two-point path (or places, one row each), profile of straight corners without holes: the profile repeated in ONE element - the louvres, slats or bars of one bay are one body, not one element each. Pieces must not overlap (repeat_overlap); touching is allowed. The body is exact for volume; set_dimension and set_section refuse it, a changed row is built anew | |
| source | No | Where the values you write come from: assumption (default, your own estimate, stamped in the file) or user (only what the person named word for word; it then reads as the file does) | |
| at_grid | No | Instead of at x, y: the crossing of two axes of an IfcGrid (straight x straight extended, straight x arc on the arc); z from at[2], else the ContainedInStructure storey, else the grid's storey. read_as names point and axes; a tag twice in its direction is refused with the list | |
| dry_run | No | Preview: the planned effect and its checks, nothing written | |
| outline | No | Closed footprint [[x,y],...] in world m, at most 1000 corners; at [0,0,z] gives its bottom plane, the body rises from it by thickness (IfcSpace, IfcSite: height) | |
| profile | No | With path (or places with path): closed section [[u,v],...] in m, as named, not centred, extruded from the first path point along it by its length. u across the path, level (vertical path: +y); v = path direction x u. No section, outline, mesh, like, dimensions. A segment run: the section about its axis through every leg and bend (gutter, channel), vertical first leg u +x. {mid:[u,v]} between two corners (after the last: the closing edge) makes that edge an arc through it; a circle: two corners, two mids. A beam or member of one section reads best as that section with the path along the bar; its side view with a path across it only where the height varies (haunch). IfcWall (gable, mono-pitch): its elevation [[s,z],...], s along the level path from its first point, z up; bottom [0,0]-[L,0], upright sides, a convex top; the path wall of the top height and dimensions.thickness (the one dimension), cut by one half space per sloped edge | |
| section | No | Cross-section by catalog name (ProfileName): HEA 200, IPE 300, CHS 273x5, BSH 120x240, AU 14. Unknown names are refused with the nearest ones. Beside elements of the class in the storey too: built from the catalog along the called axis with the called Material.Name, nothing copied; read_as names the element passed by | |
| assembly | No | With class and at, in m: a container without body and its aggregated parts of fixed classes, a type per role made per call, one material for all parts; a part of another class or section: created alone, Decomposes the container. Exactly the keys of the class - IfcCurtainWall: columns, height, mullion, panel_thickness, rows, to, transom, optional doors, windows. IfcRailing: handrail, height, post, posts, to. IfcRoof: pitch_deg, thickness, to, width. IfcStair: riser_height, risers, tread_length, waist_thickness, width, optional landing, direction. IfcStair at = middle of the first riser at floor level; with Decomposes an IfcStair no new container: its parts join that stair, placed relative to it, its attributes unchanged (set_properties); else the line runs from at to to; IfcRoof: at -> to the eave at the plate underside, the form its PredefinedType GABLE_ROOF or SHED_ROOF | |
| roll_deg | No | With path, IfcBeam/IfcMember or profile: turns the section about the path, counter-clockwise seen from the path end; 0 (default): width level | |
| IsTypedBy | No | Occurrence of this type object; beside a pattern, with outline or dimensions: neither its type, material nor psets; beside a run: its segments, bends keep their own type | |
| alignment | No | IfcAlignment (IFC4X3 only; class IfcAlignment or left out): layout and curve after the norm, aggregated to the IfcProject. Beside it only attributes Name, Description, ObjectType, PredefinedType; no IfcSegmentedReferenceCurve. The report's alignment: segments with world ends and end directions read back, length_m, deviation_m per clothoid, station_equations with distance_m. Layouts later: edit_alignment | |
| Decomposes | No | Part of this assembly or spatial node (IfcRelAggregates), GlobalId: a space its storey, a storey its building; beside an IfcStair assembly the existing IfcStair its parts join | |
| annotation | No | IfcAnnotation (class IfcAnnotation or left out): 2D in the storey plane at its height, ContainedInStructure required. Beside it only attributes Name, Description; any other field is refused field_not_for_annotation. The report's annotation: texts with height and source, text_styles (one IfcTextStyle per height, shared), context, assumption, index read back. Later: move, rotate, copy, delete, set_properties Text | |
| at_station | No | Instead of at: a point on an IfcAlignment; the element turns with the tangent. read_as names point, direction, source | |
| attributes | No | IFC attributes: Name, Elevation, PredefinedType ...; without like and unless beside a pattern of the same kind also "Material.Name" (else Moddl_Unbestimmt - name it when the user did) and "Material.Category" (picks the default colour, else by class; set_properties SurfaceColour changes it); beside one of the same kind the element takes its material (material_with_pattern), set_properties Material.Name after creating. At a type class any attribute of it (PredefinedType, OperationType ...), no path: Material and property sets by set_properties at the new type | |
| connection | No | One IfcElementAssembly: IfcPlate with holes, bolts, weld, joined by IfcRelConnectsWithRealizingElements; spacing checked to EN 1993-1-8 Tab. 3.3. Alone beside dry_run, note | |
| dimensions | No | Without template: exactly the class's own set (detail.allowed); round: IfcColumn height/radius, else radius and the depth key give a circle. IfcColumn also width, depth, height (rectangle). Beside a pattern of the class in the storey, a body of its section kind and of the same kind (PredefinedType, ObjectType as named) joins its type, material, psets - equal parts share one type; another kind (lean concrete beside a base slab) names its PredefinedType, ObjectType or IsTypedBy: built as without a pattern, own or named type (pattern_ignored); another section kind passes it by too, a slab also a pattern not lying flat; a slab thickness may come from its layers | |
| request_id | No | Your id for this call: a repeat answers the first result and writes nothing | |
| bend_radius | No | Run of 3 or more points: bend radius at the axis, no default; each bend takes bend_radius * tan(angle/2) off the legs beside it | |
| outline_from | No | IfcSpace instead of outline: the free plan cell around point between these elements (guids or set); islands become holes, openings do not count, a gap is refused. With at [0,0,z], dimensions.height | |
| corner_radius | No | Path of 3 or more points beside profile or section, or of a wall: radius at the axis per inner corner (one number: all; list: one per inner corner, 0 = mitre); tangent points R*tan(angle/2) off the corner, refused with the largest possible where a leg is short | |
| profile_voids | No | Holes in profile, each a closed loop of the same form, wholly inside and apart; at most 1024 corners in all | |
| reinforcement | No | One bar set (IfcReinforcingBar, n bodies) with its type, in the host REINFORCEMENT_UNIT; moves with the host. Bars: at most 2000, 1 km each, 40 km together, and bar metres times host corners 160000. Mesh: at most 800 mats in one laying, about 150 km of wire, counted in mats. Alone beside dry_run, note | |
| cardinal_point | No | IfcBeam, IfcColumn, IfcMember with section (two-point path or at) or profile (two-point path): which point of the section box lies on the system line (the path; at: the extrusion axis through it). IFC numbering, u across, v up: 1 2 3 bottom left/centre/right, 4 5 6 middle, 7 8 9 top (8 top centre); 10-19 centroid and shear centre, only for doubly symmetric sections. Writes IfcMaterialProfileSetUsage.CardinalPoint and moves the body; measured after placing. Left out: section centred, profile as named, no usage | |
| expect_contacts | No | Intended contacts: checks.contacts splits into as_expected, missing, surprises; an omitted kind is not judged | |
| AdheresToElement | No | IfcSurfaceFeature (IFC4X3) only, required there: the element it marks (IfcRelAdheresToElement), placed relative to it, at stays world; no ContainedInStructure | |
| AssignedToGroups | No | Run or device only: the existing system it joins, Name or GlobalId; none is created | |
| ContainedInStructure | No | The spatial structure element it stands in, Name or GlobalId: a storey, or without one a site, building or facility part (IfcBridgePart ...), placed relative to it, at stays world; never derived but a storey; never at a spatial node (IfcSpace: Decomposes) |