Hi Jason,

I appreciate your response and the priorities you shared. Over the past 
four days, I have been thoroughly exploring the structure2d.py 
<https://github.com/BorekSaheli/sympy/blob/structure2d/sympy/physics/continuum_mechanics/structure2d.py>
 
and Beam.py 
<https://github.com/sympy/sympy/blob/master/sympy/physics/continuum_mechanics/beam.py>
 
modules. I found structure2d.py 
<https://github.com/BorekSaheli/sympy/blob/structure2d/sympy/physics/continuum_mechanics/structure2d.py>
 
exciting, readable, and easy to work with. As part of this process, I 
solved 80+ problems using different combinations of available functions 
within the module, covering most of them to understand their capabilities 
and limitations better. This hands-on experience has given me deeper 
insight into its functionality and highlighted areas where improvements or 
additions could be made.

While the module is well-structured and logically sound, I noticed several 
areas that could be refined:

*Key Observations* 

   - *Function Behavior Inconsistencies:* Some functions lack basic 
   validation checks. For instance, when applying a distributed load without 
   specifying end values, the draw function assumes default values, whereas 
   the apply_load function fails to add it as a distributed load. 
   Additionally, many methods allow users to enter inputs in any order without 
   proper validation, leading to incorrect calculations or failures, 
   especially in complex systems with multiple members. 
   - *Missing Functionalities:* Some methods are only partially 
   implemented. For example, the apply_load function currently supports only 
   point and distributed loads, but not ramp or parabolic loads. Additionally, 
   several key methods available in Beam.py are missing in structure2d.py. 
   Adding these would significantly enhance the module's ability to handle 
   more advanced structural problems. 
   - *Lack of Documentation & Examples:* Neither the .py file nor the 
   module documentation contains structured examples or detailed comments, 
   making it difficult for users to fully understand and utilize its 
   capabilities. 
   - *Limited Test Cases:* The current test suite does not comprehensively 
   cover all cases and functionalities. Expanding test coverage would improve 
   reliability and prevent potential regressions. 
   - *Plotting Limitations:* The module lacks proper visualization 
   enhancements. Plots miss key elements such as units, labels, and load 
   values, and they do not always provide a perfectly analyzed square-type 
   representation. Additionally, the default graph often lacks the proper axes 
   which , makes it not neat as the structures overlaps with the top borders. 

*Proposed Contributions* 

   - *Refining the Existing Implementation* – Addressing inconsistencies 
   and improving method robustness. 
   - *Expanding Functionality* – Implementing missing features and adding 
   key methods from Beam.py to enhance versatility. 
   - *Comprehensive Documentation & Examples* – Creating structured 
   documentation and usage examples to improve accessibility. 
   - *Strengthening Test Coverage* – Developing a more extensive test suite 
   to validate correctness and reliability. 
   - *Enhancing Plotting & Visualization* – Improving graphical outputs by 
   ensuring proper labels, units, load values, and clearer structural 
   representations. 

I would love to hear your thoughts and suggestions on these observations. 
If there are additional aspects you'd like me to focus on, please let me 
know—I’d be happy to explore them further.

If these align with your expectations, I’ll begin drafting my GSoC proposal 
and start working on a PR to submit alongside it. I have also compiled a 
list of specific issues I encountered while solving problems,
- When order=0 and end_x, end_y are not provided, the draw function assigns 
default end values, but apply_load does not, causing inconsistencies.
- If an invalid order is given, the function fails without a proper error 
message.
- The apply_load function lacks support for ramp loads and parabolic loads.
- Some loads do not appear correctly in the graphical representation.
- Distributed loads applied at (2.5,5) do not get plotted.
- Certain loads are missing entirely from the visualization.
- If supports are defined before loads, reaction calculations fail.
- Graph defaults to (0, -y) when no supports or loads exist, making 
visualization unclear.
- Graph lacks auto-adjustment for better readability.
- No proper validation checks when applying loads at points not on the beam.
- Lack of error messages when end_x, end_y values are missing but required.
- Order 5 is incorrectly considered a distributed load without strict 
checks.

- Graph lacks essential features like units, scale, grids, and borders for 
analysis.

Looking forward to your feedback!

Best regards,
*Udayagiri Saibabu*

On Monday, March 10, 2025 at 12:17:44 AM UTC+5:30 moore...@gmail.com wrote:

The most recent work on that module is: 
https://github.com/sympy/sympy/pull/27130 which we would like to merge and 
get it working more generally. This expands the capabilities to more 
structure types. That would be my hope for any near future work.

Fixing bugs seen in this list of issues is also priority: 
https://github.com/sympy/sympy/issues?q=is%3Aissue%20state%3Aopen%20label%3Aphysics.continuum_mechanics
Jason
moorepants.info
+01 530-601-9791


On Sun, Mar 9, 2025 at 2:02 PM sai udayagiri <saibabu....@gmail.com> wrote:

Hello,

I am Sai Udayagiri, a physics graduate from India with a strong interest in 
computational mechanics and symbolic mathematics. I have been exploring 
SymPy for over a month now, focusing particularly on the Physics module. 
While going through the GSOC ideas page, the projects "Implement Specific 
Forces and Torques 
<https://github.com/sympy/sympy/wiki/GSoC-Ideas#classical-mechanics-implement-specific-forces-and-torques>"
 
and "Create a Rich 2D Beam Solving System 
<https://github.com/sympy/sympy/wiki/GSoC-Ideas#continuum-mechanics-create-a-rich-2d-beam-solving-system>"
 
caught my attention.

To evaluate my suitability for the project, I thoroughly explored the 
continuum mechanics module for the past 10 days, reviewed the past 
contributions by Sampad, Jashan 
<https://github.com/jashan498/GSoC/wiki/GSoC-2018-Report-Jashanpreet-Singh:-Create-a-Rich-Beam-Solving-System>,
 
Ishan 
<https://github.com/sympy/sympy/wiki/GSoC-2019-Final-Report-Ishan-Joshi:-Creating-a-rich-beam-solving-system-and-extending-continuum-mechanics-module>,
 
Prakhar 
<https://github.com/sympy/sympy/wiki/GSoC-2021-Report-Prakhar-Saxena-:-Creating-a-Rich-Beam-Solver-and-Extending-Continuum-Mechanics-Module>,
 
Advait 
<https://github.com/sympy/sympy/wiki/GSoC-2022-Report-Advait-Pote-:-Extending-the-Continuum-Mechanics-Module>,
 
and Ishan Pandhare, and studied NPTEL 
<https://youtube.com/playlist?list=PLyqSpQzTE6M_MEUdn1izTMB2yZgP1NLfs&si=_YBViE6P2L7yHl1r>
 
lectures on beams to deepen my theoretical understanding. Although I had a 
subject on Solid Mechanics during my college coursework, I found that the 
work in this module extends beyond my prior knowledge. Hence, I invested 
time in researching both the theory behind beam mechanics and SymPy's 
implementation of 2D and 3D beam modules.
Observations & Ideas for Improvement 

After analyzing previous work and Current Project Requirements, I observed 
several areas that could be improved or expanded upon:

*Enhanced Plotting Capabilities*

   - Currently, all plots in the beams module are very simple and lack 
   customization. 
   - I believe we can enhance default plotting features and allow users to 
   fully customize plots . 

*Support for More Complex Beam Structures*

   - The module currently does not allow beams with different material 
   properties at joints. 
   - I am unsure about the complexity and importance of this feature, so I 
   would love to hear thoughts from the community. 

*Support for Complex Cross-Sections*

   - The module does not fully support non-standard cross-sections. 
   - Integrating with the geometry package could allow defining arbitrary 
   cross-sections for 2D and 3D beams. 

*Expanded Problem Examples & Documentation*

   - Adding more real-world problem examples would help users better 
   understand the module. 
   - Examples showcasing more analytical solutions would be beneficial. 

My Technical Experience 

*Python :* I have experience in symbolic computation, data structures, and 
numerical methods.
*Git & Open Source* :I am familiar with Git, GitHub workflows, and 
open-source contribution practices.

I would love to hear the views of the community and potential mentors 
Advait, Prakhar regarding these ideas. If these are not the most desirable 
changes, I would appreciate guidance on what improvements are needed for 
the SymPy Beams Module.

Looking forward to your response!

Thanks & Best Regards,
Sai Udayagiri

-- 
You received this message because you are subscribed to the Google Groups 
"sympy" group.
To unsubscribe from this group and stop receiving emails from it, send an 
email to sympy+un...@googlegroups.com.
To view this discussion visit 
https://groups.google.com/d/msgid/sympy/683d2c01-63ff-4b65-b101-499e8eca0375n%40googlegroups.com
 
<https://groups.google.com/d/msgid/sympy/683d2c01-63ff-4b65-b101-499e8eca0375n%40googlegroups.com?utm_medium=email&utm_source=footer>
.

-- 
You received this message because you are subscribed to the Google Groups 
"sympy" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to sympy+unsubscr...@googlegroups.com.
To view this discussion visit 
https://groups.google.com/d/msgid/sympy/f7861f96-c410-4359-92a4-780a5d811eaen%40googlegroups.com.

Reply via email to