clwainwright / cosmotransitions Goto Github PK

In finiteT.py: from scipy.misc import factorial as fac
Newer versions of scipy - factorial is in scipy.special

I am using CosmoTransition to get the action and tunneling of an MSSM potential with 3 scalar fields, and I write my potential in full-tunneling () example. In this regard, I have two questions:
First, to substitute path_pts (array_like), should I have an array with three points that my fields are?
I would like to ask you that when I substitute path_pts (array_like) in full.tunneling(), should I have an array with three points that my fields are? For example, the metastable min is when all of them are 0, and the lower one is when (h=3, L=1.5, tau=1.5), so I write it like this : [3,1.5,1.5], [0,0,0], but I get an error that:

raise PotentialError("V(phi_metaMin) <= V(phi_absMin); "
cosmoTransitions.tunneling1D.PotentialError: ('V(phi_metaMin) <= V(phi_absMin); tunneling cannot occur.', 'stable, not metastable').

But here the potential at first point is -31 which is lower than the potential at 0. I don't know if my points are wrong or the way I write path_pts and if I should change other parts of the code in the case of 3 fields.

Second, in this example, I think the default is calculating action for finite temperature, but I need to change it to 0-temperature, How can I do this?

Hello
I’m trying to use your package CosmoTransition for computing phase transition in some BSM models. However, after having read the documentation and tried a few tests I have some problems, that I try to ask you with two examples.

I’m dealing with a 1D potential and making a cross-checks with a code that I have implemented in Mathematica.

In the file thermal_tunneling_a.py I have set a standard mexican hat potential, line 59, no field dependent mass (all set to zero lines 69-71). If I run the code however instead than getting a minimum at 246.0, I get a minimum at 246.00000381
Is this just a precision error or am I missing some physics?

The second example is more involved, thermal_tunneling_a.py

I have tried to implement the original coleman-weinberg model with a gauged U(1). No potential at tree level, line 59, and field dependent mass as written in lines 59-71. I know that the potential at low and high-temperature should have the form in the figure (light low T, black high T), where the SSB is given by the T=0 loop potential and the symmetry is restored at high temperature.

However, with my implementation in your package I get strange results, e.g calling

findMinimum(T=0)

I get ~1648, which seems weird. I’m sure I’m missing something crucial in the implementation. Please let me know if you can help

Thanks for you time

Daniele

thermal_tunneling_a.txt
thermal_tunneling_b.txt

Screen Shot 2019-05-30 at 3.56.03 PM.png

I am trying to change the default reheating temperature T_max to a high temperature value and this is creating errors. This is for a beyond the SM high temperature model for a additional Complex scalar field.
File "C:\Users\AppData\Local\Programs\Python\Python38-32\lib\site-packages\cosmoTransitions\transitionFinder.py", line 921, in findAllTransitions start_phase = phases[getStartPhase(phases, V)] File "C:\Users\AppData\Local\Programs\Python\Python38-32\lib\site-packages\cosmoTransitions\transitionFinder.py", line 619, in getStartPhase assert len(phases) > 0 AssertionError
I have changed inside the generic_potential line(102-120)

  `def __init__(self, *args, **dargs):
    self.Ndim = 0
    self.x_eps = .001
    self.T_eps = .001
    self.deriv_order = 4
    self.renormScaleSq = 1.e13**2
    self.Tmax = 1.e13

    self.num_boson_dof = self.num_fermion_dof = None

    self.phases = self.transitions = None  # These get set by getPhases
    self.TcTrans = None  # Set by calcTcTrans()
    self.TnTrans = None  # Set by calcFullTrans()

    self.init(*args, **dargs)

    if self.Ndim <= 0:
        raise ValueError("The number of dimensions in the potential must "
                         "be at least 1.")`

Since such calculation takes alot of computing time. I thought to change the step size but due to this the program is not even running

Hello,

I am trying to obtain the bubble profile for a 1D scalar potential but keep running into the r > rmax integration error. I used Mathematica to obtain critical temperatures for specific coupling constants in the potential and of course, when I plot the potential in Python with these pre-determined parameters, it plots correctly. When I try to use SingleFieldInstanton.findProfile() from the tunneling1D.py file however (identical to the way it is done in the toy example in CosmoTransitions), it produces the integration error. The code with the potential and leading to this issue is attached and named CT_BubbleProfile.txt.

CT_BubbleProfile.txt

I tried obtaining a bubble profile for a temperature of T = 170 by solving the bubble wall equation in Mathematica and obtained the plots in "single_dark_scalar.pdf".

Single_dark_scalar.pdf

Now I am stuck as to why the error in CT should exist considering the bubble size from Mathematica is ~0.1 and when I print the values of r and rmax during a CT findProfile() run, it prints ~108 and ~40 respectively.

Any help on how to progress past this point would be greatly appreciated, thanks!

[https://github.com/clwainwright/CosmoTransitions/blob/ba3339784f1a91fb23d374467cf83a948509aaa3/cosmoTransitions/pathDeformation.py#L761-L762](float instead of int)
[https://github.com/numpy/numpy/issues/15345#issuecomment-575917093](cosmoTransition issue)

After updating the numpy to the latest version I am facing this problem

Dear All,

I tried to use np.linalg.eig(m) to diagonalize a 3\times 3 mass matrix depending on fields, and got an error:
"numpy.linalg.linalg.LinAlgError: Last 2 dimensions of the array must be square".

It seems to that the shape of 'X' change the mass matrix, and the mass matrix is no longer 3\times 3
How to solve the problem?

Many thanks

How to use Cosmotransition to qualitatively determine a thick-walled bubble or a thin-walled bubble? For example, when the transition temperature T_n is much smaller than the critical temperature T_c, we will definitely obtain a thick-walled bubble? Is this right?
Many thanks

It seems that the generic_potential.py module does not include the daisy improved corrections. Are there any way to improve this? Or this package actually have this?

Hi CL Wainwright,

I am using CosmoTransitions for the first time. The original code as
framed by you is working well. However, I faced a particular issue which
is defined below:

While I try to calculate the d(S3/T)/dT at T_nucleation, I add the
following line in the testModel1.py file.

p = pd.fullTunneling([[286.39824899, 382.19727026], [231.1029627,
-136.8226031]], m.Vtot([231.1029627, -136.8226031], 84.23+1e-03),
m.gradV([231.1029627, -136.8226031], 84.23+1e-03))

in the following format:

pathDeformation.fullTunneling([ findMinimum( [(Low VeV), T=Tn+1e-03),
findMinimum( (High VeV), T=Tn+1e-03)], Vtot(X,T=Tn+1e-03),
gradV(X,T=Tn+1e-03))

The low VeV and high VeV array that I have considered here is taken from
the output generated using your code for "#Low-T transition
(first-order)" corresponding to "Tnuc: 84.2382008774623" (i.e low_vev :
[286.39824899 382.19727026]; high_vev : [ 231.1029627 -136.8226031]).

I was considering to calculate dS3/dT in the following way:

dS3/dT ~ (S3(Tn+1e-3) - S3(Tn)) / 1e-3

While running I get the following error.

Traceback (most recent call last):
File "testModel1_pb1.py", line 201, in
p = pd.fullTunneling([[286.39824899, 382.19727026], [231.1029627,
-136.8226031]], m.Vtot([231.1029627, -136.8226031], 84.23+1e-03),
m.gradV([231.1029627, -136.8226031], 84.23+1e-03))

File
"/home/aks/.local/lib/python2.7/site-packages/cosmoTransitions/pathDeformation.py",
line 950, in fullTunneling
extend_to_minima=True)
File
"/home/aks/.local/lib/python2.7/site-packages/cosmoTransitions/pathDeformation.py",
line 759, in init
xtol=1e-6, disp=0)[0]
File
"/home/aks/.local/lib/python2.7/site-packages/scipy/optimize/optimize.py",
line 416, in fmin
res = _minimize_neldermead(func, x0, args, callback=callback, **opts)
File
"/home/aks/.local/lib/python2.7/site-packages/scipy/optimize/optimize.py",
line 559, in _minimize_neldermead
fsim[k] = func(sim[k])
File
"/home/aks/.local/lib/python2.7/site-packages/scipy/optimize/optimize.py",
line 300, in function_wrapper
return function((wrapper_args + args))
File
"/home/aks/.local/lib/python2.7/site-packages/cosmoTransitions/pathDeformation.py",
line 756, in V_lin
def V_lin(x, p0, dp0, V): return V(p0+xdp0)
TypeError: 'numpy.float64' object is not callable

Separetely, I can obtain the Vtot(X,T=Tn+1e-03) and gradV(X,T=Tn+1e-03)
succesfully for any X.

Could you give some direction on the above-mentioned error message, or
is there any basic issue while I am trying to calculate the same using
"pathDeformation.fullTunneling()". It'd also be helpful if you provide
some insights on which output value (or, from where) we have to consider
the "X".

Dear All,
I am getting the following error in MacOS Mojave. I am new to Python. numpy version:1.18.1, scipy version: 1.4.1, matplotlib version: 3.2.0.
Thanks,
S Rakshit

-----------------output------------------
Rakshits-MacBook:sr-test rakshit$ ipython3
Python 3.7.7 (default, Mar 10 2020, 15:43:03)
Type 'copyright', 'credits' or 'license' for more information
IPython 7.13.0 -- An enhanced Interactive Python. Type '?' for help.

In [1]: from testModel1 import model1

In [2]: m=model1()

In [3]: alltrans=m.findAllTransitions()
Tracing phase starting at x = [295.56323266 406.39105772] ; t = 0.0
Tracing minimum up
traceMinimum t0 = 0
.................................................................................................................
Tracing phase starting at x = [ 215.33159683 -149.94745675] ; t = 118.20010359187555
Tracing minimum down
traceMinimum t0 = 118.2
........................................................................................
Tracing minimum up
traceMinimum t0 = 118.2
...............................................................................................................................................................................................
Tracing phase starting at x = [ 0.00116792 -0.00088472] ; t = 223.70229847224445
Tracing minimum down
traceMinimum t0 = 223.702
...................
Tracing minimum up
traceMinimum t0 = 223.702
............................................
Tunneling from phase 1 to phase 0 at T=77.61682
high_vev = [ 234.29595961 -111.48237945]
low_vev = [289.27693899 389.92592893]

TypeError Traceback (most recent call last)
/usr/local/lib/python3.7/site-packages/numpy/core/function_base.py in linspace(start, stop, num, endpoint, retstep, dtype, axis)
116 try:
--> 117 num = operator.index(num)
118 except TypeError:

TypeError: 'numpy.float64' object cannot be interpreted as an integer

During handling of the above exception, another exception occurred:

TypeError Traceback (most recent call last)
in
----> 1 alltrans=m.findAllTransitions()

/usr/local/lib/python3.7/site-packages/cosmoTransitions/generic_potential.py in findAllTransitions(self, tunnelFromPhase_args)
621 self.getPhases()
622 self.TnTrans = transitionFinder.findAllTransitions(
--> 623 self.phases, self.Vtot, self.gradV, tunnelFromPhase_args)
624 # Add in the critical temperature
625 if self.TcTrans is None:

/usr/local/lib/python3.7/site-packages/cosmoTransitions/transitionFinder.py in findAllTransitions(phases, V, dV, tunnelFromPhase_args)
925 del phases[start_phase.key]
926 trans = tunnelFromPhase(phases, start_phase, V, dV, Tmax,
--> 927 **tunnelFromPhase_args)
928 if trans is None and not start_phase.low_trans:
929 start_phase = None

/usr/local/lib/python3.7/site-packages/cosmoTransitions/transitionFinder.py in tunnelFromPhase(phases, start_phase, V, dV, Tmax, Ttol, maxiter, phitol, overlapAngle, nuclCriterion, verbose, fullTunneling_params)
835 try:
836 Tnuc = optimize.brentq(_tunnelFromPhaseAtT, Tmin, Tmax, args=args,
--> 837 xtol=Ttol, maxiter=maxiter, disp=False)
838 except ValueError as err:
839 if err.args[0] != "f(a) and f(b) must have different signs":

/usr/local/lib/python3.7/site-packages/scipy/optimize/zeros.py in brentq(f, a, b, args, xtol, rtol, maxiter, full_output, disp)
778 if rtol < _rtol:
779 raise ValueError("rtol too small (%g < %g)" % (rtol, _rtol))
--> 780 r = _zeros._brentq(f, a, b, xtol, rtol, maxiter, args, full_output, disp)
781 return results_c(full_output, r)
782

/usr/local/lib/python3.7/site-packages/cosmoTransitions/transitionFinder.py in tunnelFromPhaseAtT(T, phases, start_phase, V, dV, phitol, overlapAngle, nuclCriterion, fullTunneling_params, verbose, outdict)
707 tobj = pathDeformation.fullTunneling(
708 [x1,x0], V, dV_, callback_data=T,
--> 709 **fullTunneling_params)
710 tdict['instanton'] = tobj
711 tdict['action'] = tobj.action

/usr/local/lib/python3.7/site-packages/cosmoTransitions/pathDeformation.py in fullTunneling(path_pts, V, dV, maxiter, fixEndCutoff, save_all_steps, verbose, callback, callback_data, V_spline_samples, tunneling_class, tunneling_init_params, tunneling_findProfile_params, deformation_class, deformation_init_params, deformation_deform_params)
948 # 1. Fit the spline to the path.
949 path = SplinePath(pts, V, dV, V_spline_samples=V_spline_samples,
--> 950 extend_to_minima=True)
951 # 2. Do 1d tunneling along the path.
952 if V_spline_samples is not None:

/usr/local/lib/python3.7/site-packages/cosmoTransitions/pathDeformation.py in init(self, pts, V, dV, V_spline_samples, extend_to_minima, reeval_distances)
760 if xmin > 0.0: xmin = 0.0
761 nx = np.ceil(abs(xmin)-.5) + 1
--> 762 x = np.linspace(xmin, 0, nx)[:, np.newaxis]
763 pt_ext = pts[0] + x*dpts[0]
764 pts = np.append(pt_ext, pts[1:], axis=0)

<array_function internals> in linspace(*args, **kwargs)

/usr/local/lib/python3.7/site-packages/numpy/core/function_base.py in linspace(start, stop, num, endpoint, retstep, dtype, axis)
119 raise TypeError(
120 "object of type {} cannot be safely interpreted as an integer."
--> 121 .format(type(num)))
122
123 if num < 0:

TypeError: object of type <class 'numpy.float64'> cannot be safely interpreted as an integer.

In [4]:

The papers

https://arxiv.org/pdf/1310.4174.pdf
https://arxiv.org/pdf/1208.1765.pdf

both suggest replacing scipy.optimize.fmin with scipy.optimize.fminbound in pathDeformation.fullTunneling. It is argued that this helps with shallow minima. I can't find the relevant calls in pathDeformation.fullTunneling. Perhaps the papers refer to an older version of the code?

I would like to implement a model with a low vev (~ keV/MeV), I tried to start with input values of 1e-1, 1e-2 but I can't find any transition, I get this result from both m.findAllTransitions() and m.calcTcTrans():

Tracing phase starting at x = [0.09917074] ; t = 0.0
Tracing minimum up
traceMinimum t0 = 0
..................
[]

Is the problem due to the small numerical values? Should I re-scale all my quantities?
Or do you think it is related to a problem in the implementation of the mode?

(

The model works for values of the vev between 1 and 70, for higher values I get the following error

/home/francesco/.local/lib/python3.8/site-packages/cosmoTransitions/tunneling1D.py:415: RuntimeWarning: overflow encountered in double_scalars
r *= 10

)

Hi,

I have a model with a barrier at tree level. The minimums at tree level are (218 , 221 , 0) and (0 , -266 , 0).
As you see the output of m.calcTcTrans() shows a degeneracy with its critical temperature but the output of m.findAllTransitions() is none!!!
I have tried lots of inputs but the results are the same!

Will you help me to understand what is going wrong?

Another question: I am so sorry for this amateur question! I am not an expert in Python.
How can I call functions like nuclCriterion() and tunnelFromPhase() for a potential which is defined in generic_potential class? When I run the following commands, I get the following error:
In [1]: import myModel3
In [2]: m = myModel3.model3()
In [3]: m.nuclCriterion()

AttributeError Traceback (most recent call last)
in ()
----> 1 m.nuclCriterion()

AttributeError: model3 instance has no attribute 'nuclCriterion'

/CosmoTransitions/cosmoTransitions/pathDeformation.py:303: FutureWarning: `rcond` parameter will change to the default of machine precision times ``max(M, N)`` where M and N are the input matrix dimensions.
To use the future default and silence this warning we advise to pass `rcond=None`, to keep using the old, explicitly pass `rcond=-1`.
  self._beta, residues, rank, s = np.linalg.lstsq(self._X, phi)

This is for numpy.__version__ '1.15.1'. Should be easy to silence, might push it later, as there are only two instances,

https://github.com/clwainwright/CosmoTransitions/search?q=np.linalg.lstsq&unscoped_q=np.linalg.lstsq

Hi

I am trying to use CosmoTransitions, but get an error when running your TestMOdel1.py in example file?

/usr/lib/python2.7/dist-packages/scipy/integrate/quadpack.py:357: IntegrationWarning: The integral is probably divergent, or slowly convergent.
warnings.warn(msg, IntegrationWarning)

So what happens here?
Thanks!

Hi!

I have encountered an issue when using the generic_potential.findAllTransitions function in CosmoTransitions. For a 1D toy model that I am considering, the function generic_potential.findAllTransitions fails to find a transition even though I am manually able to tune the temperature T until the nucleation criterion S/T = 140 is satisfied, when S is calculated manually (fixing the false and the true vacuum to reasonable values, based on plots of the effective potential around the critical temperature) using pathDeformation.fullTunneling.

I think I have been able to trace the issue to the option extend_to_minima in pathdeformation.SplinePath, which is set to True when the latter function is called from pathDeformation.fullTunneling. What happens when I call generic_potential.findAllTransitions is that the minimum temperature Tmin for the phase tracing of the false vacuum at X = 0 is set to the temperature when the minimum disappears (the second derivative becomes negative). My model features a Z2 symmetry, and when the extend_to_minima option is set to True, the minimum is pushed from X = 0 down to (approximately) X = -v, with X = +v denoting the true vacuum. Of course, a transition is then no longer possible, because there is (approximately) no difference between the potential at the false vacuum and the true vacuum.

Please note that the above issue cannot, as far as I can tell, be resolved by making using of the forbidPhaseCrit function to say exclude phases with a negative vev. Indeed, the forbidPhaseCrit function is not invoked when extending the minimum in pathdeformation.SplinePath if extend_to_minima is set to True.

I would like to know if the above behavior should be considered a bug or not, and what the best way to resolve it would be. In principle, I can just change extend_to_minima from True to False in pathDeformation.SplinePath, but perhaps this is not an ideal solution.

From what I understand, the minimum temperature Tmin from the phase tracing well be set to the value when the phase in question disappears. If so, it seems to me that extend_to_minima being set to True will always give somewhat strange behavior at T = Tmin whether or not the model has a particular symmetry, because the minimum would always be moved to some more or less strange value due to the phase no longer being a minimum at T = Tmin, by definition of Tmin.

Thanks in advance!

Hi,

I ran the package for the standard model with top quark, W and Z bosons. The output contains an extra solution which should not exist in the standard model!
Will you help me to understand what is wrong?

Regards,
Sam

Hello,

In transitionFinder.secondOrderTrans, it is written the following:
rdict['low_vev'] = rdict['high_vev'] = high_phase.X[0]
Instead, I would write for rdict['low_vev'] the following: rdict['low_vev'] = low_phase.X[-1].

Indeed, in the case where I encounter this problem, I get from getPhases() the following:
{0: Phase(key=0, X=[[246.1 1.723e-08], ..., [159 5.111e-10]], T=[0, ..., 124.3], dXdT=[[0 -0], ..., [-3.765 -1.815e-09]],
1: Phase(key=1, X=[[-2.774e-05 85.45], ..., [-9.095e-07 1.805]], T=[97.18, ..., 195.9], dXdT=[[7.368e-05 -0.1567], ..., [7.58e-08 -114.6]],
2: Phase(key=2, X=[[-3.3e-06 -0.0004679], ..., [1.482e-10 2.056e-08]], T=[196, ..., 1000], dXdT=[[7.227e-08 0.04722], ..., [-3.333e-13 -5.087e-11]]}.

Next from calcTcTrans() I get
{'Tcrit': 195.95176635278509,
'low_vev': array([-3.30010242e-06, -4.67890908e-04]),
'high_vev': array([-3.30010242e-06, -4.67890908e-04]),
'low_phase': 1,
'high_phase': 2,
'action': 0.0,
'instanton': None,
'trantype': 2,
'Delta_rho': 0.0}
where we clearly see that 'low_vev' and 'high_vev' are identical while 'low phase' and 'high_phase' are different. Therefore if I want to know in which direction was the transition I will get (0,0)->(0,0) instead of (0,0) -> (0, phi2).
(Of course, it is technically ok to have identical low_vev and high_vev since this is a 2nd-order (and thus smooth) phase transition, so the position of the true vacuum will start to evolve from the position of the false one.)

Hi,
I have started to use CosmoTransitions for studying 3 field scalar model for phase transition. The two-field model, supplied as an example (testModel1.py) with the package, works good, but just by following the steps as mentioned in the documentation (arxiv:1109.4189), I get an error for the command "m.findAllTransitions()" for the 3 field case with an v^2 s_3 ^2 term.
[m=testModel1.model()]

I have defined Ndim = 3 and phi3 as = X[...,2] along with other changes in an edited version of testModel1.py (attached below as .txt file
testModel1.txt
). Then it shows to be "IndexError: index 2 is out of bounds for axis 0 with size 2 ". Tracing back to m.getPhases(), it seems to be the error in the step TraceMultiMin inside the TransitionFinder file.

Can you please help me get out of this error ? Thanks in advance.

Hi Max,

I'm having a problem where it seems that cosmotransitions is returning an incorrect nucleation temperature. I think the issue is related to Nikita's closed issue.

When I extract S_3 / T from cosmotransitions and plot it as a function of T I get a 'U' shape, similar to that on Thomas Konstandin 'Tunnel probability' and 'Effective model' slides here: https://indico.cern.ch/event/367218/contributions/867645/attachments/730035/1001752/seminar_v3.pdf

Physics wise, I think the phase transition should happen at the highest T for which S_3 / T < 140. However, cosmotransitions returns the lowest T. When I run findAllTransitions() on my model it returns

Tracing phase starting at x = [ 2.46897564e+02 1.08843929e-05] ; t = 0.0
Tracing minimum up
traceMinimum t0 = 0
......................................
Tracing phase starting at x = [ 1.03336990e-05 7.85294117e+01] ; t = 160.798047076
Tracing minimum down
traceMinimum t0 = 160.798
................
Tracing minimum up
traceMinimum t0 = 160.798
..........
Tunneling from phase 1 to phase 0 at T=0
high_vev = [ 1.71292948e-06 8.01430724e+01]
low_vev = [ 2.46897553e+02 4.47880524e-07]
Path deformation converged. 14 steps. fRatio = 1.52553e-02
Path deformation converged. 1 steps. fRatio = 1.12174e-02
Action = 899.508455384 , T = 0.0
Tunneling from phase 1 to phase 0 at T=0.00025
high_vev = [ -1.04758247e-06 8.01430723e+01]
low_vev = [ 2.46897552e+02 -1.33137054e-07]
Path deformation converged. 14 steps. fRatio = 1.52553e-02
Path deformation converged. 1 steps. fRatio = 1.12174e-02
Action = 899.508119181 , T = 0.00025
Tunneling from phase 1 to phase 0 at T=0.0005
high_vev = [ 1.54123341e-07 8.01430720e+01]
low_vev = [ 2.46897552e+02 4.82574080e-07]
Path deformation converged. 14 steps. fRatio = 1.52553e-02
Path deformation converged. 1 steps. fRatio = 1.12174e-02
...

so we can see that it is starting the tunnelling calculation from T = 0 and working upwards. This would be fine if, as you mention in your reply to Nikita, S_3 / T is monotonically increasing, but for my model that doesn't seem to be the case.

Can you confirm if it is likely that cosmotransitions is indeed making a mistake here, or is there something I'm missing? If it is making a mistake, is there a method you would suggest to follow to fix it? For instance, is there a way to get it to work downwards from the critical temperature?

Many thanks,

Michael

I may be missing something here, but I see that finding dS/dT is still listed as a todo. As far as I can tell, the action returned by transitionFinder.tunnelFromPhase is the action at the nucleation temperature. But it doesn't seem like the action as a function of temperature is stored.

Is there an easy way to do this? I saw that returning the derivative dS/dT was a todo so I imagine my request is not straightforward.

If there isn't, I would be interested in making these changes myself if that's useful. Thanks!

Hi Max,

In testModel1.py file, you used the manual definition of eigenvalues of the field-dependent mass matrix in 'boson_massSq' function.

Is it possible to use the 'eigvalsh' function from 'scipy'?
I have tried this but I got an error, it seems that is due to the shape of 'X' in some steps which results in a non-square matrix.

Cheers,
Sam

I have difficulty calculating the Euclidean action S_E and tunneling rate \Gamma, as well as the derivative dV/dT and dS/dT, as a function of finite temperature T with loop-corrected effective potential.

If I understand it correctly, this effective potential can be calculated by the module generic_function.py numerically, but I couldn’t find how to pass this effective potential to tunneling1D.py, which is used to calculate S_E and \Gamma. It seems that I am only allowed to input the analytical expression of the potential function to class SingleFieldInstanton. Could you please tell me if there is any way to pass numerical potential, as an array, to the class? My model has just one scaler field in one dimension.

Thank you very much.

Hi,

I'm using CosmoTransitions to analyse the phase transitions of the effective potential in http://arxiv.org/abs/1608.07578.

For many parameter points it raises the exception:

"Two phases have been found to coincide at one end "
NotImplementedError: Two phases have been found to coincide at one end but not the other. Ideally, this function would find where the two diverge, make a cut, and join them such there are no more phase redundancies.
Instead, just raise an exception.

Is this something that could be easily implemented (either by an expert or by me with a bit of guidance)? Or is there an available work around?

Many thanks,

Mike

Hi,

I was testing the path deformation algorithm for various 1d potentials. I am parametrising my potentials such that the true and false vacua are always at 1 and 0. I noticed that in rare cases whether it succeeds is sensitive to the number of points I use in my guess of the solution (n_points below). If this is too small, I see

cosmoTransitions.tunneling1D.PotentialError:
('Minimization is placing the top of the potential barrier outside of the interval
defined by phi_bar and phi_metaMin. Assume that the barrier does not exist.', 'no barrier')

Of course, increasing n_points is rather easy, but maybe something is wrong with the code here, I'm not sure.

"""
Path deformation from CT
========================
"""

from cosmoTransitions.pathDeformation import fullTunneling as path_deform
import numpy as np

# Make potential

alpha = 0.719387755102
E = -1.

def V(f):
    """
    :returns: 1d potential
    """
    return E * ((4. * alpha - 3.) / 2. * f**2 + f**3 - alpha * f**4)
    
def dV(f):
    """
    :returns: Derivative of 1d potential
    """
    return E *((4. * alpha - 3.) * f + 3. * f**2 - 4. * alpha * f**3)
    


# This number fails

# cosmoTransitions.tunneling1D.PotentialError: 
# ('Minimization is placing the top of the potential barrier outside of the interval 
# defined by phi_bar and phi_metaMin. Assume that the barrier does not exist.', 'no barrier')

n_points = 100 

# This one works

# n_points = 1000

guess_phi = np.linspace(1., 0., n_points)
guess_phi = np.reshape(guess_phi, (len(guess_phi), 1))

profile_1d, phi, action = path_deform(guess_phi, V, dV)[:3]

print "action = {}".format(action)
print "phi(r=0) = {}".format(phi[0])
print "r0 = {}".format(profile_1d.R[0])

Hi Max,

I'm trying to understand how findAllTransitions works a bit better. One of the key functions it calls is tunnelFromPhase. In that function on line 823 we have

 if nuclCriterion(outdict[Tmin]['action'], Tmax) < 0:

Should that be

if nuclCriterion(outdict[Tmin]['action'], Tmin) < 0:

or is there some argument as to why the former condition is more useful?