Functions
tuple[float, float, float]	wall_geom_center (list[float] params)

dict	contact_pair (int i, int j)

dict	material (float horizon, float K, float G, float Gc)

dict	build (float final_time, int time_steps, str out_path, int output_interval, float omega=-20.0 *math.pi)

None	main ()

None	validate_ic (list[tuple] rows)

dict	build (float final_time, int time_steps, str out_path, int output_interval)

Variables
	HERE = Path(__file__).resolve().parent

str	MESH = HERE / "meshes"

str	CSV = HERE / "particle_locations_0.csv"

dict	R_REF = {0: 0.001, 1: 0.001, 2: 0.001, 3: 0.003, 4: 0.003, 5: 0.003}

list	MESH_FILES

list	WALL_PARAMS

dict	KN

dict	K_MAT = {0: 1.0e4, 1: 1.0e5, 2: 1.0e5}

float	KN_FACTOR = 1.0

float	R_IN = 0.02

float	R_SMALL = 0.001

float	R_LARGE = 0.003

float	MESH_SIZE = R_SMALL / 5.0

float	HORIZON = 2.0 * MESH_SIZE

float	R_OUT = R_IN + 1.5 * MESH_SIZE

float	L_BAR = 0.005

float	W_BAR = 1.5 * MESH_SIZE

float	BETA_N_FACTOR = 100.0

float	EPSILON = 0.95

float	CONTACT_RADIUS_FACTOR = 0.95

float	FRICTION_COEFF = 0.5

bool	DAMPING_ON = False

bool	FRICTION_ON = False

str	DAMPING_LAW = "off"

str	FRICTION_LAW = "coulomb_simple"

bool	CORRECT_VOLUME = False

int	SEARCH_INTERVAL = 40

float	SEARCH_FACTOR = 10.0

float	NEAR_BD_TOL = 0.5

str	BOND_BREAK = "tension"

str	SELF_CONTACT = "broken_bond_kn"

str	WALL_CONTACT = "meshed"

bool	RANDOM_ROTATION = False

float	OMEGA = -40.0 * math.pi

tuple	ROT_CENTER = (-0.2 * R_IN, 0.2 * R_IN, 0.0)

Detailed Description

Build modular JSON for attrition sim1 — match main GIF deck.

Reference (main README links attrition_test_sim1.gif here):
  examples/PeriDEM/attrition_tests/sim1_multi_particle_circ_tri_drum_with_rotating_cylinder_with_protrusion

Physics from that problem_setup.py: Kn_Factor=1, Gc=50/100, Bond_Break unset
(tension default). Wall site = ComplexGeom centroid so mesh at origin is not shifted.

Build modular JSON for attrition sim2 — explicit keys, match main GIF deck.

Reference:
  examples/PeriDEM/attrition_tests/sim2_multi_particle_circ_tri_drum_hex_with_rotating_cylinder_with_protrusion_thin_container_and_change_rotation_rate

Every field that has a dangerous modular default is set explicitly (see
INPUT_DEFAULTS.md). No reliance on omitted-key defaults.

Function Documentation

◆ build() [1/2]

dict gen_input.build	(	float	final_time,
		int	time_steps,
		str	out_path,
		int	output_interval
	)

Definition at line 168 of file gen_input.py.

) -> dict:
    particles = []
    rows = []
    with CSV.open() as f:
        next(f)
        for line in f:
            parts = [p.strip() for p in line.split(",")]
            if len(parts) < 6:
                continue
            zi = int(float(parts[0]))
            x, y, z = float(parts[1]), float(parts[2]), float(parts[3])
            r, o = float(parts[4]), float(parts[5])
            rows.append((zi, x, y, z, r, o))
            large = zi >= 4
            particles.append(
                {
                    "x": x,
                    "y": y,
                    "z": z,
                    "theta": o,
                    "s": r / R_REF[zi],
                    "geom_id": zi,
                    "mat_id": 1 if large else 0,
                    "contact_id": 1 if large else 0,
                }
            )
 
    validate_ic(rows)
 
    wall_id = len(particles)
    wcx, wcy, wcz = wall_geom_center(WALL_PARAMS)
    particles.append(
        {
            "x": wcx,
            "y": wcy,
            "z": wcz,
            "theta": 0.0,
            "s": 1.0,
            "geom_id": 8,
            "mat_id": 1,
            "contact_id": 2,
            "is_wall": True,  # no PD on wall; DOFs locked by Displacement_BC
        }
    )
 
    gen = {
        "Method": "From_File",
        "Random_Rotation": RANDOM_ROTATION,
        "Data": {"N": len(particles)},
    }
    for i, p in enumerate(particles):
        gen["Data"][str(i)] = p
 
    particle_geom = {
        "Sets": 9,
        "Set_1": {"Type": "circle", "Parameters": [R_SMALL, 0.0, 0.0, 0.0]},
        "Set_2": {"Type": "triangle", "Parameters": [R_SMALL, 0.0, 0.0, 0.0]},
        "Set_3": {
            "Type": "drum2d",
            "Parameters": [R_SMALL, R_SMALL * 0.4, 0.0, 0.0, 0.0],
        },
        "Set_4": {"Type": "hexagon", "Parameters": [R_SMALL, 0.0, 0.0, 0.0]},
        "Set_5": {"Type": "circle", "Parameters": [R_LARGE, 0.0, 0.0, 0.0]},
        "Set_6": {"Type": "triangle", "Parameters": [R_LARGE, 0.0, 0.0, 0.0]},
        "Set_7": {
            "Type": "drum2d",
            "Parameters": [R_LARGE, R_LARGE * 0.4, 0.0, 0.0, 0.0],
        },
        "Set_8": {"Type": "hexagon", "Parameters": [R_LARGE, 0.0, 0.0, 0.0]},
        "Set_9": {
            "Type": "complex",
            "Vec_type": ["circle", "circle", "rectangle"],
            "Vec_flag": ["plus", "minus", "plus"],
            "Parameters": WALL_PARAMS,
        },
    }
 
    mesh = {"Sets": 9}
    for i, name in enumerate(MESH_FILES):
        mesh[f"Set_{i + 1}"] = {"File": str((MESH / name).resolve())}
 
    contact = {
        "Sets": 3,
        "Damping_Law": DAMPING_LAW,
        "Friction_Law": FRICTION_LAW,
        "Correct_Volume": CORRECT_VOLUME,
    }
    for i in range(3):
        for j in range(i, 3):
            contact[f"Set_{i + 1}_{j + 1}"] = contact_pair(i, j)
 
    return {
        "Model": {
            "Dimension": 2,
            "Final_Time": final_time,
            "Time_Steps": time_steps,
            "Discretization_Type": {
                "Spatial": "finite_difference",
                "Time": "central_difference",
            },
            "Populate_ElementNodeConnectivity": True,
            "Quad_Approximation_Order": 2,
            "Particle_Sim_Type": "Multi_Particle",
            "MPI_Strategy": "auto",
            "Seed": 0,
            "Bond_Break": BOND_BREAK,
            "Self_Contact": SELF_CONTACT,
            "Wall_Contact": WALL_CONTACT,
        },
        "Output": {
            "Path": out_path if out_path.endswith("/") else out_path + "/",
            "Perform_Out": True,
            "Tags": [
                "Displacement",
                "Velocity",
                "Force",
                "Damage_Z",
                "Damage",
                "Particle_ID",
                "Fixity",
                "Contact_Nodes",
            ],
            "Output_Interval": output_interval,
            "Debug": 3,
            "Perform_FE_Out": False,
            "Compress_Type": "zlib",
            "File_Format": "vtu",
            "Test_Output_Interval": max(1, output_interval // 100),
            "Tag_PP": "0",
            "PVD_Collection": True,
        },
        "Force_BC": {"Gravity": [0.0, -10.0, 0.0]},
        "Displacement_BC": {
            "Sets": 1,
            "Set_1": {
                "Particle_List": [wall_id],
                "Direction": [1, 2],
                "Time_Function": {
                    "Type": "rotation",
                    "Parameters": [OMEGA, ROT_CENTER[0], ROT_CENTER[1], ROT_CENTER[2]],
                },
                "Spatial_Function": {"Type": "rotation"},
                "Zero_Displacement": False,
            },
        },
        "Particle": particle_geom,
        "Mesh": mesh,
        "Material": {
            "Sets": 2,
            "Set_1": material(HORIZON, 1.0e4, 6.0e3, 50.0),
            "Set_2": material(HORIZON, 1.0e5, 6.0e4, 100.0),
        },
        "Contact": contact,
        "Neighbor": {
            "Update_Criteria": "simple_all",
            "Search_Factor": SEARCH_FACTOR,
            "Search_Interval": SEARCH_INTERVAL,
            "Near_Bd_Nodes_Tol": NEAR_BD_TOL,
        },
        "Particle_Generation": gen,
    }
 
 

References build(), contact_pair(), main(), validate_ic(), and wall_geom_center().

Here is the call graph for this function:

◆ build() [2/2]

dict gen_input.build	(	float	final_time,
		int	time_steps,
		str	out_path,
		int	output_interval,
		float	omega = `-20.0 * math.pi`
	)

Definition at line 108 of file gen_input.py.

) -> dict:
    horizon = 6.0e-4
    particles = []
    with CSV.open() as f:
        next(f)
        for line in f:
            parts = [p.strip() for p in line.split(",")]
            if len(parts) < 6:
                continue
            zi = int(float(parts[0]))
            x, y, z = float(parts[1]), float(parts[2]), float(parts[3])
            r, o = float(parts[4]), float(parts[5])
            large = zi >= 3
            if math.hypot(x, y) + r > R_IN - 1.0e-6:
                raise SystemExit(
                    f"IC overlap: particle zone={zi} at ({x},{y}) r={r} "
                    f"extends past R_in={R_IN}"
                )
            particles.append(
                {
                    "x": x,
                    "y": y,
                    "z": z,
                    "theta": o,
                    "s": r / R_REF[zi],
                    "geom_id": zi,
                    "mat_id": 1 if large else 0,
                    "contact_id": 1 if large else 0,
                }
            )
 
    wall_id = len(particles)
    # MUST equal ComplexGeom centroid so mesh (axis at origin) is not shifted.
    wcx, wcy, wcz = wall_geom_center(WALL_PARAMS)
    particles.append(
        {
            "x": wcx,
            "y": wcy,
            "z": wcz,
            "theta": 0.0,
            "s": 1.0,
            "geom_id": 6,
            "mat_id": 1,
            "contact_id": 2,
            "is_wall": True,
        }
    )
 
    gen = {"Method": "From_File", "Random_Rotation": False, "Data": {"N": len(particles)}}
    for i, p in enumerate(particles):
        gen["Data"][str(i)] = p
 
    particle_geom = {
        "Sets": 7,
        "Set_1": {"Type": "circle", "Parameters": [0.001, 0.0, 0.0, 0.0]},
        "Set_2": {"Type": "triangle", "Parameters": [0.001, 0.0, 0.0, 0.0]},
        "Set_3": {"Type": "drum2d", "Parameters": [0.001, 0.0004, 0.0, 0.0, 0.0]},
        "Set_4": {"Type": "circle", "Parameters": [0.003, 0.0, 0.0, 0.0]},
        "Set_5": {"Type": "triangle", "Parameters": [0.003, 0.0, 0.0, 0.0]},
        "Set_6": {"Type": "drum2d", "Parameters": [0.003, 0.0012, 0.0, 0.0, 0.0]},
        "Set_7": {
            "Type": "complex",
            "Vec_type": ["circle", "circle", "rectangle"],
            "Vec_flag": ["plus", "minus", "plus"],
            "Parameters": WALL_PARAMS,
        },
    }
 
    mesh = {"Sets": 7}
    for i, name in enumerate(MESH_FILES):
        mesh[f"Set_{i + 1}"] = {"File": str((MESH / name).resolve())}
 
    contact = {
        "Sets": 3,
        "Damping_Law": "off",
        "Friction_Law": "coulomb_simple",
        "Correct_Volume": False,  # main DEM contact used full Vj
    }
    for i in range(3):
        for j in range(i, 3):
            contact[f"Set_{i + 1}_{j + 1}"] = contact_pair(i, j)
 
    return {
        "Model": {
            "Dimension": 2,
            "Final_Time": final_time,
            "Time_Steps": time_steps,
            "Discretization_Type": {
                "Spatial": "finite_difference",
                "Time": "central_difference",
            },
            "Populate_ElementNodeConnectivity": True,
            "Quad_Approximation_Order": 2,
            "Particle_Sim_Type": "Multi_Particle",
            "Seed": 0,
            # Bond_Break omitted → tension (PMB default)
            "Bond_Break": "tension",
            "Self_Contact": "none",
            "Wall_Contact": "meshed",
        },
        "Output": {
            "Path": out_path if out_path.endswith("/") else out_path + "/",
            "Perform_Out": True,
            "Tags": [
                "Displacement",
                "Velocity",
                "Force",
                "Damage_Z",
                "Damage",
                "Particle_ID",
                "Fixity",
                "Contact_Nodes",
            ],
            "Output_Interval": output_interval,
            "Debug": 1,
            "Perform_FE_Out": False,
            "Compress_Type": "zlib",
            "File_Format": "vtu",
            "Test_Output_Interval": max(1, output_interval // 10),
            "Tag_PP": "0",
            "PVD_Collection": True,
        },
        "Force_BC": {"Gravity": [0.0, -10.0, 0.0]},
        "Displacement_BC": {
            "Sets": 1,
            "Set_1": {
                "Particle_List": [wall_id],
                "Direction": [1, 2],
                "Time_Function": {
                    "Type": "rotation",
                    "Parameters": [omega, 0.0, 0.0, 0.0],
                },
                "Spatial_Function": {"Type": "rotation"},
                "Zero_Displacement": False,
            },
        },
        "Particle": particle_geom,
        "Mesh": mesh,
        "Material": {
            "Sets": 2,
            # paper Gc: small=50, large/wall=100
            "Set_1": material(horizon, 1.0e4, 6.0e3, 50.0),
            "Set_2": material(horizon, 1.0e5, 6.0e4, 100.0),
        },
        "Contact": contact,
        "Neighbor": {
            "Update_Criteria": "simple_all",
            "Search_Factor": 10.0,
            "Search_Interval": 40,
            "Near_Bd_Nodes_Tol": 0.5,
        },
        "Particle_Generation": gen,
    }
 
 

References contact_pair(), and wall_geom_center().

Referenced by build(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ contact_pair()

dict gen_input.contact_pair	(	int	i,
		int	j
	)

Definition at line 80 of file gen_input.py.

def contact_pair(i: int, j: int) -> dict:
    a, b = min(i, j), max(i, j)
    return {
        "Contact_Radius_Factor": 0.95,
        "Damping_On": False,
        "Friction_On": False,
        "Kn": KN[(a, b)],
        "K": 2.0 * K_MAT[a] * K_MAT[b] / (K_MAT[a] + K_MAT[b]),
        "Epsilon": 0.95,
        "Friction_Coeff": 0.5,
        "Kn_Factor": KN_FACTOR,
        "Beta_n_Factor": 100.0,
    }
 
 

Referenced by build(), and build().

Here is the caller graph for this function:

◆ main()

None gen_input.main ( )

Definition at line 269 of file gen_input.py.

def main() -> None:
    for mesh in MESH_FILES:
        if not (MESH / mesh).is_file():
            raise SystemExit(f"missing mesh {MESH / mesh}")
    if not CSV.is_file():
        raise SystemExit(f"missing {CSV}")
 
    short = build(0.01, 100000, "runs/out", 2000)
    medium = build(0.03, 300000, "runs/out", 3000)
    paper = build(0.1, 1000000, "runs/out", 2500)
    (HERE / "input_short.json").write_text(json.dumps(short, indent=2) + "\n")
    (HERE / "input_medium.json").write_text(json.dumps(medium, indent=2) + "\n")
    (HERE / "input.json").write_text(json.dumps(paper, indent=2) + "\n")
    n = short["Particle_Generation"]["Data"]["N"]
    wid = short["Displacement_BC"]["Set_1"]["Particle_List"][0]
    wp = short["Particle_Generation"]["Data"][str(wid)]
    print(
        f"wrote input_short/medium/json (N={n}, wall_id={wid}, KnF={KN_FACTOR}, "
        f"Gc=50/100, Bond_Break=tension, Damp=off, "
        f"wall_site=({wp['x']:.6f},{wp['y']:.6f}))"
    )
 
 

References build(), and main().

Referenced by build(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ material()

dict gen_input.material	(	float	horizon,
		float	K,
		float	G,
		float	Gc
	)

Definition at line 95 of file gen_input.py.

def material(horizon: float, K: float, G: float, Gc: float) -> dict:
    return {
        "Type": "PDState",
        "Horizon": horizon,
        "Density": 1200.0,
        "Compute_From_Classical": True,
        "K": K,
        "G": G,
        "Gc": Gc,
        "Influence_Function": {"Type": 1},
    }
 
 

◆ validate_ic()

None gen_input.validate_ic ( list[tuple] rows )

Definition at line 145 of file gen_input.py.

def validate_ic(rows: list[tuple]) -> None:
    bar = (R_IN - L_BAR, -0.5 * W_BAR, R_IN, 0.5 * W_BAR)
    errors: list[str] = []
    for i, (zi, x, y, z, r, o) in enumerate(rows):
        if zi not in R_REF:
            errors.append(f"row {i}: bad zone {zi}")
            continue
        if math.hypot(x, y) + r > R_IN - 1.0e-9:
            errors.append(
                f"row {i} zone={zi}: past R_in (hyp+r={math.hypot(x, y) + r:.6e})"
            )
        if not (x + r < bar[0] or x - r > bar[2] or y + r < bar[1] or y - r > bar[3]):
            errors.append(f"row {i} zone={zi}: overlaps protrusion AABB")
    for i in range(len(rows)):
        for j in range(i + 1, len(rows)):
            dx = rows[i][1] - rows[j][1]
            dy = rows[i][2] - rows[j][2]
            if math.hypot(dx, dy) < rows[i][4] + rows[j][4] - 1.0e-9:
                errors.append(f"overlap rows {i},{j}")
    if errors:
        raise SystemExit("IC invalid:\n  " + "\n  ".join(errors[:40]))
 
 

Referenced by build().

Here is the caller graph for this function:

◆ wall_geom_center()

tuple[float, float, float] gen_input.wall_geom_center ( list[float] params )

Signed-volume centroid of circle(+)-circle(-)-rectangle(+) wall.

Definition at line 65 of file gen_input.py.

def wall_geom_center(params: list[float]) -> tuple[float, float, float]:
    """Signed-volume centroid of circle(+)-circle(-)-rectangle(+) wall."""
    r_out, cx0, cy0, cz0 = params[0], params[1], params[2], params[3]
    r_in, cx1, cy1, cz1 = params[4], params[5], params[6], params[7]
    x0, y0, z0, x1, y1, z1 = params[8:14]
    a_out = math.pi * r_out * r_out
    a_in = math.pi * r_in * r_in
    a_rect = abs(x1 - x0) * abs(y1 - y0)
    vol = a_out - a_in + a_rect
    cx = (a_out * cx0 - a_in * cx1 + a_rect * 0.5 * (x0 + x1)) / vol
    cy = (a_out * cy0 - a_in * cy1 + a_rect * 0.5 * (y0 + y1)) / vol
    cz = (a_out * cz0 - a_in * cz1 + a_rect * 0.5 * (z0 + z1)) / vol
    return cx, cy, cz
 
 

Referenced by build(), and build().

Here is the caller graph for this function:

Variable Documentation

◆ BETA_N_FACTOR

float gen_input.BETA_N_FACTOR = 100.0

Definition at line 81 of file gen_input.py.

◆ BOND_BREAK

str gen_input.BOND_BREAK = "tension"

Definition at line 93 of file gen_input.py.

◆ CONTACT_RADIUS_FACTOR

float gen_input.CONTACT_RADIUS_FACTOR = 0.95

Definition at line 83 of file gen_input.py.

◆ CORRECT_VOLUME

bool gen_input.CORRECT_VOLUME = False

Definition at line 89 of file gen_input.py.

◆ CSV

str gen_input.CSV = HERE / "particle_locations_0.csv"

Definition at line 19 of file gen_input.py.

◆ DAMPING_LAW

str gen_input.DAMPING_LAW = "off"

Definition at line 87 of file gen_input.py.

◆ DAMPING_ON

bool gen_input.DAMPING_ON = False

Definition at line 85 of file gen_input.py.

◆ EPSILON

float gen_input.EPSILON = 0.95

Definition at line 82 of file gen_input.py.

◆ FRICTION_COEFF

float gen_input.FRICTION_COEFF = 0.5

Definition at line 84 of file gen_input.py.

◆ FRICTION_LAW

str gen_input.FRICTION_LAW = "coulomb_simple"

Definition at line 88 of file gen_input.py.

◆ FRICTION_ON

bool gen_input.FRICTION_ON = False

Definition at line 86 of file gen_input.py.

◆ HERE

gen_input.HERE = Path(__file__).resolve().parent

Definition at line 17 of file gen_input.py.

◆ HORIZON

float gen_input.HORIZON = 2.0 * MESH_SIZE

Definition at line 24 of file gen_input.py.

◆ K_MAT

dict gen_input.K_MAT = {0: 1.0e4, 1: 1.0e5, 2: 1.0e5}

Definition at line 60 of file gen_input.py.

◆ KN

dict gen_input.KN

Initial value:

=  {
    (0, 0): 7.368284e20,
    (0, 1): 1.339688e21,
    (0, 2): 1.339688e21,
    (1, 1): 7.368284e21,
    (1, 2): 7.368284e21,
    (2, 2): 7.368284e21,
}

Definition at line 51 of file gen_input.py.

◆ KN_FACTOR

float gen_input.KN_FACTOR = 1.0

Definition at line 61 of file gen_input.py.

◆ L_BAR

float gen_input.L_BAR = 0.005

Definition at line 27 of file gen_input.py.

◆ MESH

str gen_input.MESH = HERE / "meshes"

Definition at line 18 of file gen_input.py.

◆ MESH_FILES

list gen_input.MESH_FILES

Initial value:

=  [
    "mesh_cir_small_0.msh",
    "mesh_tri_small_0.msh",
    "mesh_drum2d_small_0.msh",
    "mesh_cir_large_0.msh",
    "mesh_tri_large_0.msh",
    "mesh_drum2d_large_0.msh",
    "mesh_wall_0.msh",
]

Definition at line 22 of file gen_input.py.

◆ MESH_SIZE

float gen_input.MESH_SIZE = R_SMALL / 5.0

Definition at line 23 of file gen_input.py.

◆ NEAR_BD_TOL

float gen_input.NEAR_BD_TOL = 0.5

Definition at line 92 of file gen_input.py.

◆ OMEGA

float gen_input.OMEGA = -40.0 * math.pi

Definition at line 98 of file gen_input.py.

◆ R_IN

float gen_input.R_IN = 0.02

Definition at line 62 of file gen_input.py.

◆ R_LARGE

float gen_input.R_LARGE = 0.003

Definition at line 22 of file gen_input.py.

◆ R_OUT

float gen_input.R_OUT = R_IN + 1.5 * MESH_SIZE

Definition at line 26 of file gen_input.py.

◆ R_REF

dict gen_input.R_REF = {0: 0.001, 1: 0.001, 2: 0.001, 3: 0.003, 4: 0.003, 5: 0.003}

Definition at line 21 of file gen_input.py.

◆ R_SMALL

float gen_input.R_SMALL = 0.001

Definition at line 21 of file gen_input.py.

◆ RANDOM_ROTATION

bool gen_input.RANDOM_ROTATION = False

Definition at line 97 of file gen_input.py.

◆ ROT_CENTER

tuple gen_input.ROT_CENTER = (-0.2 * R_IN, 0.2 * R_IN, 0.0)

Definition at line 99 of file gen_input.py.

◆ SEARCH_FACTOR

float gen_input.SEARCH_FACTOR = 10.0

Definition at line 91 of file gen_input.py.

◆ SEARCH_INTERVAL

int gen_input.SEARCH_INTERVAL = 40

Definition at line 90 of file gen_input.py.

◆ SELF_CONTACT

str gen_input.SELF_CONTACT = "broken_bond_kn"

Definition at line 95 of file gen_input.py.

◆ W_BAR

float gen_input.W_BAR = 1.5 * MESH_SIZE

Definition at line 28 of file gen_input.py.

◆ WALL_CONTACT

str gen_input.WALL_CONTACT = "meshed"

Definition at line 96 of file gen_input.py.

◆ WALL_PARAMS

list gen_input.WALL_PARAMS

Initial value:

=  [
021,
0,
0,
0,
02,
0,
0,
0,
014,
    -0.0015,
0,
02,
0015,
0,
]

Definition at line 33 of file gen_input.py.

Functions

Variables

Detailed Description

Function Documentation

◆ build() [1/2]

◆ build() [2/2]

◆ contact_pair()

◆ main()

◆ material()

◆ validate_ic()

◆ wall_geom_center()

Variable Documentation

◆ BETA_N_FACTOR

◆ BOND_BREAK

◆ CONTACT_RADIUS_FACTOR

◆ CORRECT_VOLUME

◆ CSV

◆ DAMPING_LAW

◆ DAMPING_ON

◆ EPSILON

◆ FRICTION_COEFF

◆ FRICTION_LAW

◆ FRICTION_ON

◆ HERE

◆ HORIZON

◆ K_MAT

◆ KN

◆ KN_FACTOR

◆ L_BAR

◆ MESH

◆ MESH_FILES

◆ MESH_SIZE

◆ NEAR_BD_TOL

◆ OMEGA

◆ R_IN

◆ R_LARGE

◆ R_OUT

◆ R_REF

◆ R_SMALL

◆ RANDOM_ROTATION

◆ ROT_CENTER

◆ SEARCH_FACTOR

◆ SEARCH_INTERVAL

◆ SELF_CONTACT

◆ W_BAR

◆ WALL_CONTACT

◆ WALL_PARAMS