MClump Namespace Reference

Functions
def	import_or_install_modules ()
def	main ()

Variables
bool	NumbaInstalled = True

Function Documentation

import_or_install_modules()

def MClump.import_or_install_modules

(

)

def import_or_install_modules():
    # This function automatically installs required packages if they are missing
    global NumbaInstalled
    try:
        __import__('stl')
    except ImportError:
        print("Package numpy-stl not installed, installing...")
        pip.main(['install', 'numpy-stl'])
    try:
        __import__('numba')
    except ImportError:
        print("Numba not detected (manual installation required), proceed without it")
        NumbaInstalled = False
    return
 
import_or_install_modules()
 
 

References Eigen::internal.print().

main()

def MClump.main

(

)

def main():
    # Load baseline parameters - options (OPT) and model data (DATA)
    OPT, DATA = Baseline()
 
    # Set up terminal output
    clr = colorClass()
    clr.set_use_colors(OPT['useColors'])
    clr.def_colors()
 
    # Hello tag
    print(clr.END + clr.BOLD + clr.VIOLET + "-------------------------------------------")
    print(clr.END + clr.BOLD + clr.VIOLET + "     MercuryDPM clump generation tool      ")
    print(clr.END + clr.BOLD + clr.VIOLET + "-------------------------------------------")
 
    # Modification of baseline by the command line arguments (if any)
    if (len(sys.argv) == 3):  # Full format: run -m 2
        if (sys.argv[1] == "-m"):
            OPT['mode'] = int(sys.argv[2])
 
    # Disable numba usage if enabled, but not installed
    OPT['useNumba'] = OPT['useNumba'] and NumbaInstalled
 
    if OPT['useNumba']:
        if (OPT['verbose']): print(clr.END + clr.BOLD + clr.GREEN + "Just in time compilation is enabled")
    else:
        if (OPT['verbose']): print(clr.END + clr.BOLD + clr.RED + "Just in time compilation is disabled, voxel grid computations may be slow")
 
 
 
    # Main program
    if OPT['mode']==1:   # 1 - start with the list of pebbles, compute inertia by summation over pebbles
        out = "Mode 1"
        if (OPT['verbose']): out +=": clump input from the list of pebbles, inertial properties via summation over pebbles"
        print(clr.BOLD + clr.GREEN + out)
        # load the input data
        if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Loading pebble configuration..." + clr.BLUE)
        OPT, DATA = LoadPebbles(OPT, DATA)
        if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Done")
 
        # Compute mass, center of mass, tensor of inertia, principal directions,
        # shift to center of mass and rotate to principal directions.
        if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Computing inertial properties..." + clr.BLUE)
        OPT,DATA = ComputeInertiaFromPebbles(OPT, DATA)
        if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Done")
 
        # compute inertial properties
        if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Output clump data..." + clr.BLUE)
        OPT, DATA = OutputClumpData(OPT, DATA)
        if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Done")
 
 
    if OPT['mode']==2:   # 2 - start with the list of pebbles, compute inertia by voxelization
        out = "Mode 2"
        if (OPT['verbose']): out += ": clump input from the list of pebbles, inertial properties are via voxel grid"
        print(clr.BOLD + clr.GREEN + out)
        # load the input data
        if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Loading pebble configuration..." + clr.BLUE)
        OPT, DATA = LoadPebbles(OPT, DATA)
        if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Done")
 
        # Compute mass, center of mass, tensor of inertia, principal directions,
        # shift to center of mass and rotate to principal directions.
 
        if OPT['useNumba']:
            from Src.InertiaComputationsVoxelGrid import ComputeInertiaFromVoxelGrid
            if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Computing inertial properties..." + clr.BLUE)
            OPT, DATA = ComputeInertiaFromVoxelGrid(OPT, DATA)
            if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Done")
 
        else:
            from Src.InertiaComputationsVoxelGridNonumba import compute_inertia_from_voxel_grid_nonumba
            if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Computing inertial properties..." + clr.BLUE)
            OPT, DATA = compute_inertia_from_voxel_grid_nonumba(OPT, DATA)
            if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Done")
 
 
        # Output clump data
        if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Output clump data..." + clr.BLUE)
        OPT, DATA = OutputClumpData(OPT, DATA)
        if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Done")
 
 
    if OPT['mode']==3:   # 3 - inertia from stl, external generator of pebbles
        out = "Mode 3"
        if (OPT['verbose']):
            out += ": external clump generation, inertial properties from stl"
        print(clr.BOLD + clr.GREEN + out)
 
        # load stl mesh
        if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Loading stl configuration..." + clr.BLUE)
        OPT, DATA = LoadMesh(OPT, DATA)
        if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Done")
 
        # load pebbles
        if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Loading pebble configuration..." + clr.BLUE)
        OPT, DATA = LoadPebbles(OPT, DATA)
        if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Done")
 
        # Compute mass, center of mass, tensor of inertia, principal directions,
        # shift to center of mass and rotate to principal directions.
        if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Computing inertial properties..." + clr.BLUE)
        OPT, DATA = ComputeInertiaMixed(OPT, DATA)
        if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Done")
 
 
        # Output clump data
        if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Output clump data..." + clr.BLUE)
        OPT, DATA = OutputClumpData(OPT, DATA)
        if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Done")
 
    if OPT['mode']==4:   # 4 - generation of stl sequence for Blender
        out = "Mode 4"
        if (OPT['verbose']):
            out += ": generation of stl sequence for Blender"
        print(clr.BOLD + clr.GREEN + out)
 
        # load stl mesh
        if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Loading stl configuration..." + clr.BLUE)
        OPT, DATA = LoadMesh(OPT, DATA)
        if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Done")
 
        # load pebbles
        if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Loading pebble configuration..." + clr.BLUE)
        OPT, DATA = LoadPebbles(OPT, DATA)
        if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Done")
 
        # Compute mass, center of mass, tensor of inertia, principal directions,
        # shift to center of mass and rotate to principal directions.
        if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Computing inertial properties..." + clr.BLUE)
        OPT, DATA = ComputeInertiaMixed(OPT, DATA)
        if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Done")
 
 
        # Save stl sequence
        if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Saving stl sequence..." + clr.BLUE)
        OPT, DATA = SaveStlSequence(OPT, DATA)
        if (OPT['verbose']): print(clr.BOLD + clr.YELLOW + "Done")
 
 
 

References InertiaComputationsPebbles.ComputeInertiaFromPebbles(), InertiaComputationsVoxelGrid.ComputeInertiaFromVoxelGrid(), InertiaComputationsMixed.ComputeInertiaMixed(), int(), InputData.LoadMesh(), LoadPebbles(), OutputData.OutputClumpData(), Eigen::internal.print(), and SaveToStl.SaveStlSequence().

Variable Documentation

NumbaInstalled

bool MClump.NumbaInstalled = True