Metadata-Version: 2.1
Name: DiscreteLatticeMech
Version: 1.0.0
Summary: DiscreteLatticeMech
Home-page: https://github.com/nkarathan/DiscreteLatticeMech
Author: Nikos Karathanasopoulos
Author-email: karathanasopoulosn@gmail.com
License: MIT
Description: # DiscreteLatticeMech
        
        #### Introduction
        
        DiscreteLattichMech is a discrete element based mechanics Python package for the computation of the effective static properties of two-dimensional, metamaterial lattice structures. The software makes use of the asymptotic expansion form of the inner kinematic and static variables of the lattice structure, exploiting its spatial periodicity. As such, it makes use of the smallest repetitive material unit, substantially reducing the cost of full-scale computations. For the identification of the basic cell’s parameters, a dedicated Graphical User Interface (GUI) is provided. The code computes the complete, Cauchy mechanics, stiffness and compliance matrix, providing access to all elastic material moduli. In particular, the normal, shear and bulk moduli, as well as the Poisson’s ratio values of the architectured material structures are elaborated. Its formulation favors the analysis of a wide range of lattice designs, establishing a fundamental link between micro- and macro-scale material properties.
        
        #### Project Layout
        
        - `DiscreteLatticeMech/Core`: python library
        - `DiscreteLatticeMech/GUI`: GUI tool
        - `DiscreteLatticeMech/SampleInputs`: sample input configuration files
        - `tests`: test that checks
        - `examples`: set of python script examples
        - `videos:`: a set of videos demonstrating the usage of the GUI tool
        
        #### Requirement
        
        Python 3.5 or higher is needed by both the core module and the GUI tool.
        
        The package requirements for the core module are the following:
        - `numpy`
        - `jsonschema`
        - `matplotlib`
        - `pytest`
        
        The additional package requirements for the GUI tool are the following:
        - `wxpython`
        
        Please note that the GUI tool has been tested on Windows platforms only.
        
        #### Installation
        
        Within your Python environment and the root folder of the package,
        type the following command in your terminal to install it:
        
        - `pip3 install .`
        
        Otherwise, you can install the PyPi distribution:
        
        - `pip3 install DiscreteLatticeMech`
        
        The GUI tool is part of the package distribution. However, it's addition dependencies must be installed
        by running the following command:
        
        - `pip3 install wxpython`
        
        #### Testing
        
        Just type `pytest` to check the installation by automatically running the script in the `tests` folder.
        
        #### Examples
        
        To run the examples, just type `python3 examples/example1.py` and `python3 examples/example2.py`, from the root folder.
        
        The first example reads the input configuration file (`InputData_SquareEx.json`), available in the `examples` folder and creates a new folder with the results of the run.
        
        The second example sets the input data in a Python dictionary and calls the solver, generating another folder
        with the same results.
        
        The contents of `InputData_SquareEx.json` are shown below:
        ```
        {
            "NumberElements": 2,
            "e_1": [1,0],
            "e_2": [0,1],
            "Y_1": [1, 0],
            "Y_2": [0, 1],
            "NumberNodes": 1,
            "Ob": [1,1],
            "Eb": [1,1],
            "Delta1": [1,0],
            "Delta2": [0,1],
            "Ka": [21,21],
            "Kb": [0.21,0.21],
            "Lb": [10,10],
            "tb": [1,1],
            "L1": 10,
            "L2": 10
        }
        ```
        
        where,
        - `"NumberElements"`: number of elements
        - `"e_1", "e_2"`: direction vectors of each element
        - `"Y_1", "Y_2"`: define the global periodicity vectors
        - `"NumberNodes"`: number of inner nodes
        - `"Ob", "Eb", "Delta1", "Delta2"`: list of origin and end points along with delta
        - `"Ka", "Kb"`: list of element axial and bending stiffness
        - `"Lb", "tb"`: list of element lengths and thickness
        - `"L1", "L2"`: norm of the periodicity vectors
        
        
        A typical usage of the Python module, similarly to `example1.py`, is depicted below:
        
        ```
        from DiscreteLatticeMech import Solver, Writer
        
        if __name__ == "__main__":
        
            if len(sys.argv) == 1:
                print("Usage: {} <input filename (json)>".format(sys.argv[0]))
                sys.exit(1)
            else:
                filepath = sys.argv[1]
        
            try:
                with open(filepath, 'r') as f:
                    data = json.load(f)
            except IOError as error:
                print("could not open input file {}".format(filepath))
                sys.exit(1)
        
            # create a DiscreteLatticeMech solver object
            solver = Solver()
        
            # initialize and call the solver and get the solution
            solver.solve(data)
        
            # create a write object
            writer = Writer()
        
            # write the results
            writer.WriteTensorsToFile(solver.InputData, solver.CMatTensor, solver.FlexMatTensor)
            writer.WriteEffectivePropertiesToFile(solver.Bulk, solver.Ex, solver.Ey, solver.Poissonyx, solver.Poissonxy, solver.G, solver.rho)
        
            # create some plots
            writer.PlotEffectiveProperties(solver.Bulk, solver.Ex, solver.Ey, solver.Poissonyx, solver.Poissonxy, solver.G)
        
        ```
        
        The users can specify a configuration file as runtime argument to the `example1.py` script,
        for instance `python3 examples/example1.py examples/InputData_SquareEx.json`
        This command will automatically create a folder `Results_<data>_<time>`, where <date> and <time>
        the current date and time on the system, with the following files:
        
        - `InputData.json`: copy of the input configuration InputData
        - `CMatrix.txt`, `FlexMatrix.txt`: computed matrices
        - `EffectProperties.txt`: computed effective properties
        - `NSB_Moduli.png`, `NormalToShear.png`, `PoissonRation.png`: plots of the computed effective properties
        
        #### Using the GUI tool:
        The GUI is mainly provided as a support tool for the creation of the input JSON file that is necessary for the analysis of a certain lattice structure. It allows for the direct graphical parsing of different lattice geometries, through the definition of the nodes, elements and periodicity vectors of the primal material unit. The created input can be thereafter independently used as previously illustrated in the examples section. Different examples of the use of the GUI tool are provided in the `Videos` folder. 
        
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved
Classifier: Operating System :: OS Independent
Description-Content-Type: text/markdown
