ans = 
Results for
function varargout = Ring6GeVAB(K1,AntiB,LA,MB,BLen,DLen)
%%%% parameters
if 0
K1=[3.1846 -3.1943 -2.7480 2.7482 2.4617 -1.7087 2.9818 ...
3.6102 0 -0.1129 -1.5851 -1.7727];
AntiB=[-0.0020 -0.0061];
LA=[0.5303 5.9419 0.6043];
MB=[1.2000 1.1000 1.0000 0.8000];
BLen=[1.8000 1.8000 1.0000 0.8000];
DLen=[0 0 0 0];
end
Energy=6.0*10^9;
%%Standard Cell
DS0H =atdrift('DS0H', (2.96+DLen(4))/5 ,'DriftPass');
DS0={DS0H DS0H DS0H DS0H DS0H }';
DS1 =atdrift('DS1', 0.28 ,'DriftPass');
DS2 =atdrift('DS2', 0.14 ,'DriftPass');
DB1 =atdrift('DB1', 0.12 ,'DriftPass');
DB2 =atdrift('DB2', 0.12 ,'DriftPass');
DB3 =atdrift('DB3', 0.43+DLen(1) ,'DriftPass');
DB4 =atdrift('DB4', 0.12 ,'DriftPass');
DB5 =atdrift('DB5', 0.12 ,'DriftPass');
DB6 =atdrift('DB6', 0.43+DLen(1) ,'DriftPass');
DB7 =atdrift('DB7', 0.12 ,'DriftPass');
DB8 =atdrift('DB8', 0.12 ,'DriftPass');
DA1 =atdrift('DA1', 0.12+DLen(2) ,'DriftPass');
DA2 =atdrift('DA2', 0.20,'DriftPass');
DA3 =atdrift('DA3', 0.14,'DriftPass');
DA4 =atdrift('DA4', 0.28+DLen(3),'DriftPass');
KQ=K1(1:8);
QS1=atquadrupole('QS1' , 0.30 ,KQ(1),'StrMPoleSymplectic4RadPass');
QS2=atquadrupole('QS2' , 0.20 ,KQ(2),'StrMPoleSymplectic4RadPass');
QB1=atquadrupole('QB1' , 0.20 ,KQ(3),'StrMPoleSymplectic4RadPass');
QB2=atquadrupole('QB2' , 0.20 ,KQ(4),'StrMPoleSymplectic4RadPass');
QB3=atquadrupole('QB3' , 0.20 ,KQ(5),'StrMPoleSymplectic4RadPass');
QB4=atquadrupole('QB4' , 0.20 ,KQ(6),'StrMPoleSymplectic4RadPass');
QA1=atquadrupole('QA1' , 0.50 ,KQ(7),'StrMPoleSymplectic4RadPass');
QA2=atquadrupole('QA2' , 0.60 ,KQ(8),'StrMPoleSymplectic4RadPass');
AntiB1=AntiB(1);
QB3=atrbend('QB3', 0.20, AntiB1, KQ(5),'BndMPoleSymplectic4RadPass','EntranceAngle',AntiB1/2, 'ExitAngle',AntiB1/2);
AntiB2=AntiB(2);
QA2=atrbend('QA2', 0.60, AntiB2,KQ(8),'BndMPoleSymplectic4RadPass', 'EntranceAngle',AntiB2/2, 'ExitAngle',AntiB2/2);
SD1 = atsextupole('SD' , 0.30, -28.365*0.0000001,'StrMPoleSymplectic4Pass');%%%-113.5678*0.00000000001,'StrMPoleSymplectic4Pass');
SD2 = atsextupole('SD' , 0.30, -28.365*0.0000001,'StrMPoleSymplectic4Pass'); %%%-113.5678*0.00000000001,'StrMPoleSymplectic4Pass');
SF = atsextupole('SF' , 0.30, 39.139*0.0000001,'StrMPoleSymplectic4Pass');%156.7516*0.00000000001,'StrMPoleSymplectic4Pass');
KB=K1(9:12);KB(1)=0;%KB(2)=0;
BAngle_p=MB;
BAngle=BAngle_p*2*pi/48/(sum(BAngle_p(1:3)*2)+BAngle_p(4))-[0 AntiB1 0 2*AntiB2];
N_Slice=5;
GRAD_Slice1=[];GRAD_Slice2=[];GRAD_Slice3=[];GRAD_Slice4=[];
for j_Slice=1:N_Slice
GRAD_Slice1=[GRAD_Slice1 KB(1)];GRAD_Slice2=[GRAD_Slice2 KB(2)];
GRAD_Slice3=[GRAD_Slice3 KB(3)];GRAD_Slice4=[GRAD_Slice4 KB(4)];
end
ANGLE_Slice1=1./(1+LA(1).*[1:N_Slice]*BLen(1)/N_Slice);
ANGLE_Slice2=flip(ANGLE_Slice1);
ANGLE_Slice3=1./(1+LA(2).*[1:N_Slice]*BLen(3)/N_Slice);
ANGLE_Slice3=[flip(ANGLE_Slice3(1:2:length(ANGLE_Slice3))) ANGLE_Slice3(3:2:length(ANGLE_Slice3))];
ANGLE_Slice4=1./(1+LA(3).*[1:N_Slice]*BLen(4)/N_Slice);
ANGLE_Slice4=[flip(ANGLE_Slice4(1:2:length(ANGLE_Slice4))) ANGLE_Slice4(3:2:length(ANGLE_Slice4))];
ANGLE_Slice1=ANGLE_Slice1/sum(ANGLE_Slice1)*BAngle(1);
ANGLE_Slice2=ANGLE_Slice2/sum(ANGLE_Slice2)*BAngle(2);
ANGLE_Slice3=ANGLE_Slice3/sum(ANGLE_Slice3)*BAngle(3);
ANGLE_Slice4=ANGLE_Slice4/sum(ANGLE_Slice4)*BAngle(4);
% figure;plot(ANGLE_Slice2*Energy/C0/BLen(1)*N_Slice,'.-r');hold on;
% figure;plot(ANGLE_Slice4*Energy/C0/BLen(4)*N_Slice,'.-b');hold on;
Bend1=LongiVFDipole_R('Bend1',BLen(1),BAngle(1),N_Slice,ANGLE_Slice1,GRAD_Slice1,'BndMPoleSymplectic4RadPass');
Bend7=LongiVFDipole_R('Bend7',BLen(1),BAngle(1),N_Slice,flip(ANGLE_Slice1),GRAD_Slice1,'BndMPoleSymplectic4RadPass');
Bend2=LongiVFDipole_R('Bend2',BLen(2),BAngle(2),N_Slice,ANGLE_Slice2,GRAD_Slice2,'BndMPoleSymplectic4RadPass');
Bend6=LongiVFDipole_R('Bend6',BLen(2),BAngle(2),N_Slice,flip(ANGLE_Slice2),GRAD_Slice2,'BndMPoleSymplectic4RadPass');
Bend3=LongiVFDipole_R('Bend3',BLen(3),BAngle(3),N_Slice,ANGLE_Slice3,GRAD_Slice3,'BndMPoleSymplectic4RadPass');
Bend5=LongiVFDipole_R('Bend5',BLen(3),BAngle(3),N_Slice,ANGLE_Slice3,GRAD_Slice3,'BndMPoleSymplectic4RadPass');
Bend4=LongiVFDipole_R_H2H('Bend4',BLen(4),BAngle(4),N_Slice,ANGLE_Slice4,GRAD_Slice4,'BndMPoleSymplectic4RadPass');
CellSR=[{DA4 QA2 DA3}'; Bend5;{ DA2 QA1 DA1}'; ...
Bend6;{ DB8 QB4 DB7 SD2 DB6 QB3 DB5 SF DB4 QB2 DB3 SD1 DB2 QB1 DB1}'; Bend7;{ DS2 QS2 DS1 QS1}'; DS0];
CellSL=[DS0 ;{QS1 DS1 QS2 DS2}'; Bend1;{ DB1 QB1 DB2 SD1 DB3 QB2 DB4 SF DB5 QB3 DB6 SD2 DB7 QB4 DB8}'; Bend2; ...
{DA1 QA1 DA2}'; Bend3;{ DA3 QA2 DA4}'];
CELL=[CellSL ;Bend4; CellSR ];
L0 = findspos(CELL,length(CELL)+1) * 48;
C0 = 299792458;
f = 500 * 10^6;
HarmNumber = round(f*L0/C0);
CAV = atrfcavity('CAV' , 0.0 ,4e+6 , HarmNumber*C0/L0, HarmNumber ,[],'CavityPass');
RING=[CELL ;{CAV} ;CELL; CELL; CELL ;CELL; CELL ;CELL; CELL; CELL; CELL;CELL;CELL; ...
CELL; CELL ;CELL; CELL ;CELL; CELL; CELL; CELL; CELL; CELL;CELL ;CELL; ...
CELL; CELL; CELL ;CELL ;CELL; CELL ;CELL ;CELL ;CELL; CELL;CELL;CELL; ...
CELL; CELL; CELL ;CELL ;CELL; CELL ;CELL ;CELL ;CELL; CELL;CELL;CELL ];
THERING =RING;
THERING = setcellstruct(THERING, 'Energy', 1:length(THERING), Energy);
varargout{1}=THERING;
%THERING = Ring6GeVAB(K1,AntiB,LA,MB,BLen,DLen)
The main round of Cody Contest 2025 kicks off today! Whether you’re a beginner or a seasoned solver, now’s your time to shine.
Here’s how to join the fun:
- Pick your team — choose one that matches your coding personality.
- Solve Cody problems — gain points and climb the leaderboard.
- Finish the Contest Problem Group — help your team win and unlock chances for weekly prizes by finishing the Cody Contest 2025 problem group.
- Share Tips & Tricks — post your insights to win a coveted MathWorks Yeti Bottle.
- Bonus Round — 2 players from each team will be invited to a fun live code-along event!
- Watch Party – join the big watch event to see how top players tackle Cody problems
Contest Timeline:
- Main Round: Nov 10 – Dec 7, 2025
- Bonus Round: Dec 8 – Dec 19, 2025
Big prizes await — MathWorks swag, Amazon gift cards, and shiny virtual badges!
We look forward to seeing you in the contest — learn, compete, and have fun!
Hi everyone!
I’m Kishen Mahadevan, Senior Product Manager at MathWorks, where I focus on controls and deep learning. I’m excited to be speaking at MATLAB EXPO this year!
In one of my sessions, I’ll share how AI-based reduced order models (ROMs) are transforming engineering workflows—using battery fast charging as an example—making it easier to reuse high-fidelity models for real-time control and deployment.
I’d love to have you join the conversation at the EXPO and right here in the community!
Feel free to drop any questions or thoughts ahead of the event.
Jack and Cleve had famously noted in the "A Preview of PC-MATLAB" in 1985: For those of you that have not experienced MATLAB, we would like to try to show you what everybody is excited about ... The best way to appreciate PC-MATLAB is, of course, to try it yourself.
Try out the end-to-end workflow of developing touchless applications with both MathWorks' tools and STM Dev Cloud from last year!
You can also register this year's EXPO. Join the Hands-On workshops to learn the latest features that make the design and deployment workflow even easier!
Parallel Computing Onramp is here! This free, one-hour self-paced course teaches the basics of running MATLAB code in parallel using multiple CPU cores, helping users speed up their code and write code that handles information efficiently.
Remember, Onramps are free for everyone - give the new course a try if you're curious. Let us know what you think of it by replying below.
From my experience, MATLAB's Deep Learning Toolbox is quite user-friendly, but it still falls short of libraries like PyTorch in many respects. Most users tend to choose PyTorch because of its flexibility, efficiency, and rich support for many mathematical operators. In recent years, the number of dlarray-compatible mathematical functions added to the toolbox has been very limited, which makes it difficult to experiment with many custom networks. For example, svd is currently not supported for dlarray inputs.
This link (List of Functions with dlarray Support - MATLAB & Simulink) lists all functions that support dlarray as of R2026a — only around 200 functions (including toolbox-specific ones). I would like to see support for many more fundamental mathematical functions so that users have greater freedom when building and researching custom models. For context, the core MATLAB mathematics module contains roughly 600 functions, and many application domains build on that foundation.
I hope MathWorks will prioritize and accelerate expanding dlarray support for basic math functions. Doing so would significantly increase the Deep Learning Toolbox's utility and appeal for researchers and practitioners.
Thank you.
A toaster that tells jokes
20%
Cinderalla's godmother for cleaning
18%
Humanoid cooks and washes dishes
34%
Oven door opens with wave of hand
7%
Mattress rocks you to sleep
16%
Mirror recommends healthy cosmetics
5%
44 votes
Excited to be here
Get ready to roll up your sleeves at MATLAB EXPO 2025 – our global online event is back, and this year we’re offering 10 hands-on workshops designed to spark innovation and deepen your skills with MATLAB Online and Simulink Online.
Whether you're exploring AI, modeling batteries, or building carbon trackers, these live workshops are your chance to:
- Work directly in MATLAB and Simulink Online
- Solve real-world challenges with guidance from MathWorks experts
- Connect with peers across industries
- Ask questions and get live feedback
Join the Experience to learn more about each workshop below!
Which workshop are you most excited to attend?!
Day 1:
- Beyond the Labels: Leveraging AI Techniques for Enlightened Product Choices
- A Hands-On Introduction to Reinforcement Learning with MATLAB and Simulink
- Curriculum Development with MATLAB Copilot and Generative AI
- Simscape Battery Workshop
- Generating Tests for your MATLAB code
Day 2:
- Hands-On AI for Smart Appliances: From Sensor Data to Embedded Code
- A Hands-On Introduction to Reduced Order Modeling with MATLAB and Simulink
- Introduction to Research Software and Development with Simulink
- Hack Your Carbon Impact: Build and Publish an Emissions Tracker with MATLAB
- How to Simulate Scalable Cellular and Connectivity Networks: A Hands-On Session
We look forward to Accelerating the Pace of Engineering and Science together!
I am excited to join this community to learn the more particularly the Matlab/Simulink
It’s an honor to deliver the keynote at MATLAB EXPO 2025. I'll explore how AI changes the game in engineered systems, bringing intelligence to every step of the process from design to deployment. This short video captures a glimpse of what I’ll share:
What excites or challenges you about this shift? Drop a comment or start a thread!
I'm developing a comprehensive MATLAB programming course and seeking passionate co-trainers to collaborate!
Why MATLAB Matters:Many people underestimate MATLAB's significance in:
- Communication systems
- Signal processing
- Mathematical modeling
- Engineering applications
- Scientific computing
Course Structure:
- Foundation Module: MATLAB basics and fundamentals
- Image Processing: Practical applications and techniques
- Signal Processing: Analysis and implementation
- Machine Learning: ML algorithms using MATLAB
- Hands-on Learning: Projects, assignments.
What I'm Looking For:
- Enthusiastic educators willing to share knowledge
- Experience in any MATLAB application area
- Commitment to collaborative teaching
Interested in joining as a co-trainer? Please comment below or reach out directly!
Online Doc + System Browser
13%
Online Doc + Dedicated Browser
13%
Offline Doc +System Browser
10%
Offline Doc + Dedicated Browser
23%
Hybrid Approach (Support All Modes)
26%
User-Definable / Fully Configurable
16%
31 votes
I'm working on training neural networks without backpropagation / automatic differentiation, using locally derived analytic forms of update rules. Given that this allows a direct formula to be derived for the update rule, it removes alot of the overhead that is otherwise required from automatic differentiation.
However, matlab's functionalities for neural networks are currently solely based around backpropagation and automatic differentiation, such as the dlgradient function and requiring everything to be dlarrays during training.
I have two main requests, specifically for functions that perform a single operation within a single layer of a neural network, such as "dlconv", "fullyconnect", "maxpool", "avgpool", "relu", etc:
- these functions should also allow normal gpuArray data instead of requiring everything to be dlarrays.
- these functions are currently designed to only perform the forward pass. I request that these also be designed to perform the backward pass if user requests. There can be another input user flag that can be "forward" (default) or "backward", and then the function should have all the necessary inputs to perform that operation (e.g. for "avgpool" forward pass it only needs the avgpool input data and the avgpool parameters, but for the "avgpool" backward pass it needs the deriviative w.r.t. the avgpool output data, the avgpool parameters, and the original data dimensions). I know that there is a maxunpool function that achieves this for maxpool, but it has significant issues when trying to use it this way instead of by backpropagation in a dlgradient type layer, see (https://www.mathworks.com/matlabcentral/answers/2179587-making-a-custom-way-to-train-cnns-and-i-am-noticing-that-avgpool-is-significantly-faster-than-maxpo?s_tid=srchtitle).
I don't know how many people would benefit from this feature, and someone could always spend their time creating these functionalities themselves by matlab scripts, cuDNN mex, etc., but regardless it would be nice for matlab to have this allowable for more customizable neural net training.
Please share with us how you are using AI in your control design workflows and what you want to hear most in our upcoming talk, 4 Ways to Improve Control Design Workflows with AI.
Arkadiy
Hello Everyone, I’m Vikram Kumar Singh, and I’m excited to be part of this amazing MATLAB community!
I’m deeply interested in learning more from all of you and contributing wherever I can. Recently, I completed a project on modeling and simulation of a Li-ion battery with a Battery Management System (BMS) for fault detection and management.
I’d love to share my learnings and also explore new ideas together with this group. Looking forward to connecting and growing with the community!
Excited for MATLAB EXPO 2025!
I’m a Master’s student in Electrical Engineering at UNSW Sydney, researching EV fleet charging and hybrid energy strategies integrating battery-electric and hydrogen fuel cell vehicles.
LinkedIn link: www.linkedin.com/in/yuanzhe-chen-6b2158351
ResearchGate link: https://www.researchgate.net/profile/Yuanzhe-Chen-9?ev=hdr_xprf
#MATLABEXPO #EV #FCEV #SmartGrid
I recently published this blog post about resources to help people learn MATLAB https://blogs.mathworks.com/matlab/2025/09/11/learning-matlab-in-2025/
What are your favourite MATLAB learning resources?
Edit 15 Oct 2025: Removed incorrect code. Replaced symmatrix2sym and symfunmatrix2symfun with sym and symfun respectively (latter supported as of 2024b).
The Symbolic Math Toolbox does not have its own dot and and cross functions. That's o.k. (maybe) for garden variety vectors of sym objects where those operations get shipped off to the base Matlab functions
x = sym('x',[3,1]); y = sym('y',[3,1]);
which dot(x,y)
dot(x,y)
which cross(x,y)
cross(x,y)
clearvars
x = symmatrix('x',[3,1]); y = symmatrix('y',[3,1]);
z = symmatrix('z',[1,1]);
sympref('AbbreviateOutput',false);
dot() expands the result, which isn't really desirable for exposition.
eqn = z == dot(x,y)
Also, dot() returns the the result in terms of the conjugate of x, which can't be simplifed away at the symmatrix level
assumeAlso(sym(x),'real')
class(eqn)
try
eqn = z == simplify(dot(x,y))
catch ME
ME.message
end
To get rid of the conjugate, we have to resort to sym
eqn = simplify(sym(eqn))
but again we are in expanded form, which defeats the purpose of symmatrix (et. al.)
But at least we can do this to get a nice equation
eqn = z == x.'*y
dot errors with symfunmatrix inputs
clearvars
syms t real
x = symfunmatrix('x(t)',t,[3,1]); y = symfunmatrix('y(t)',t,[3,1]);
try
dot(x,y)
catch ME
ME.message
end
Cross works (accidentally IMO) with symmatrix, but expands the result, which isn't really desirable for exposition
clearvars
x = symmatrix('x',[3,1]); y = symmatrix('y',[3,1]);
z = symmatrix('z',[3,1]);
eqn = z == cross(x,y)
And it doesn't work at all if an input is a symfunmatrix
syms t
w = symfunmatrix('w(t)',t,[3,1]);
try
eqn = z == cross(x,w);
catch ME
ME.message
end
In the latter case we can expand with
eqn = z == cross(sym(x),symfun(w)) % x has to be converted
But we can't do the same with dot (as shown above, dot doesn't like symfun inputs)
try
eqn = z == dot(sym(x),symfun(w))
catch ME
ME.message
end
Looks like the only choice for dot with symfunmatrix is to write it by hand at the matrix level
x.'*w
or at the sym/symfun level
sym(x).'*symfun(w) % assuming x is real
Ideally, I'd like to see dot and cross implemented for symmatrix and symfunmatrix types where neither function would evaluate, i.e., expand, until both arguments are subs-ed with sym or symfun objects of appropriate dimension.
Also, it would be nice if symmatrix could be assumed to be real. Is there a reason why being able to do so wouldn't make sense?
try
assume(x,'real')
catch ME
ME.message
end
