If you have got to the point of having to handle expressions of this size, no generic routine (like **simplify** alone or with some option) will likely be able to produce automatically (or "magically") a sensible simplification. Rather, observation of patterns plus interactively controled simplification will be much more effective. Note, however, that preventing expression swell by earlier simplification, if possible, would be even better.

For interactive simplification, the classical labels facility is a great aid, despite of its limitations. As its functionality is severely limited in Standard GUI (see acer's article in the linked thread), I find this GUI close to useless for this purpose and I prefer Classic GUI.

So, what follows is a brief account of how classical labels, routines of the package **LargeExpressions**, **collect**, **applyrule**, etc, may be used for reducing this "huge output" to an expression of about five lines on my screen, plus some equations for symbols representing frequent subexpressions. Note also that the form of this particular simplified expression depends on the specific choice of the statements, and its usefulness will depend strongly on the purpose or context (not stated by the OP).

My first observation in the output of **huge_output** was that a pair of square roots appear very frequently: **sqrt(%2/%1)** and **sqrt(%3/%1)**, where these were the lablel assignments:

%1:=4*Pi^2+beta^2-4*beta^2*Q*Pi+4*beta^2*Q^2*Pi^2
%2:=-4*Pi^2-beta^2+4*beta^2*Q^2*Pi^2+8*I*Pi^2*beta*Q
%3:=-4*Pi^2-beta^2+4*beta^2*Q^2*Pi^2-8*I*Pi^2*beta*Q

For better handling of these subexpressions, these square root terms are replaced with actual names:

with(LargeExpressions):
h1:=subsindets(huge_output,And(sqrt,Not(constant)),Veil[K]):

They are actually four constants **K[1]** to **K[4]** because the inverses are also counted as they are syntactically different. But their relationship can be seen here:

Unveil[K]([K[3]-1/K[1],K[4]-1/K[2]]);
[0, 0]

Hence it is better to substitute for just two constants:

h1a:=subs([K[3]=1/K[1],K[4]=1/K[2]],h1):

The next steps are collecting for some symbols and function calls. Here, the form of the output is very sensitive to the form of the **collect** statement, in particular to the collecting list. Hence experimentation is required for approaching to the desired target. And sometimes the usage of transformation rules as shown here may help a lot:

r:=[a::algebraic/beta^4+b::algebraic/beta^4=(a+b)/beta^4,
a::algebraic/beta^4+b::algebraic/beta^3=(a/beta+b)/beta^3,
a::algebraic/beta^3+b::algebraic/beta^3=(a+b)/beta^3]:
collect(h1a,[t,beta,K[1],K[2],sigma,exp,cos],factor):
h2:=applyrule(r,%):

Its output contains seven labels for repeated subexpressions. Again, they are substituted with names, and sum terms are collected for them:

h2a:=subsindets(%,{identical(%1),identical(%2),identical(%3),identical(%4),identical(%5),

identical(%6),identical(%7)},Veil[C]):
h3:=evalindets(h2a,`+`,x->collect(x,[seq(C[i],i=0..7)],distributed));
h3 := 1/4*2^(1/2)*exp(-1/2*x^2/sigma^2)*(K[2]^2*(1/4*Pi*(2*Pi+beta*I)+

1/2*Q*Pi^2*(Pi+beta*I)*cos(k*psi)+(-1/4*Pi*(2*Pi+beta*I)-

1/2*Q*Pi^2*(Pi+beta*I)*cos(k*psi))*exp(-1/2*sigma^2*k^2))/beta/C[2]/C[3]/C[4]*C[1]+

K[1]*K[2]*(Q*Pi^2*(Pi-I*beta)*cos(k*psi)/beta-1/2*I*Pi+

(-Q*Pi^2*(Pi-I*beta)*cos(k*psi)/beta+1/2*I*Pi)*exp(-1/2*sigma^2*k^2))/C[4]/C[2]+

K[2]/K[1]*(-1/2*Pi-Q*Pi^2*cos(k*psi)+(Q*Pi^2*cos(k*psi)+

1/2*Pi)*exp(-1/2*sigma^2*k^2))/beta/C[3]/C[4]^2*C[5]/C[1]+K[1]^2*(-1/4*Pi*

(2*Pi-I*beta)-1/2*Q*Pi^2*(3*Pi-I*beta)*cos(k*psi)+(1/4*Pi*(2*Pi-I*beta)+

1/2*Q*Pi^2*(3*Pi-I*beta)*cos(k*psi))*exp(-1/2*sigma^2*k^2))/beta/C[4]*C[3]/C[1]/C[2]+

K[1]/K[2]*(-1/2*Pi-Q*Pi^2*cos(k*psi)+(Q*Pi^2*cos(k*psi)+1/2*Pi)*exp(-1/2*sigma^2*k^2))/

beta/C[3]*C[6]/C[1]/C[2]^2+(2*Pi^2+4*Q*Pi^3*cos(k*psi)+(-2*Pi^2-4*Q*Pi^3*cos(k*psi))*

exp(-1/2*sigma^2*k^2))/beta/C[2]^2/C[3]^2/C[4]^2*C[7]/C[1]^2)/beta^3/Pi^(3/2)/sigma*t

And the equations for these names **C[1]** to **C[7] **are:

seq( C[i] = Unveil[C](C[i]), i=1..LastUsed[C]);
C[1] = -2 Q beta Pi + beta + 2 I Pi,
C[2] = -2 Q beta Pi + 2 I Pi - beta,
C[3] = 2 Q beta Pi - beta + 2 I Pi,
3 2 2
C[4] = 2 Q beta Pi + 2 I Pi + beta, C[5] = 12 Pi Q beta
2 3 2 3 2 2
- 4 I Pi beta Q + 8 Pi - 12 I Pi beta - 6 Pi beta
3 3 2 2 2 3 2 3
+ beta I, C[6] = 12 Pi Q beta + 4 I Pi beta Q + 8 Pi
2 2 3 6
+ 12 I Pi beta - 6 Pi beta - beta I, C[7] = beta
4 2 6 4 2 6 4 4
+ 12 beta Pi + 64 Pi + 48 Pi beta + 256 Pi Q beta
6 6 6 6 2 2 2 6 2
+ 96 beta Q Pi + 224 Pi Q beta - 2 Pi beta Q
4 4 6 4 2 4
- 32 Pi Q beta - 16 Pi Q beta

I find remarkable that some of the tools that I have found most useful here, like the Classic GUI, classical labels, and **applyrule**, count among those largely unmaintained for years.