A Mass Toy - The Documentation

Introduction

Mass Toy has been written with the Java 1.1 specification, and compiled with JDK 1.1.6. Java 1.0 is no longer supported, the last version compliant with 1.02, Mass Toy 0.41 is available as a zip file.

Instructions

• Insert the mass matrix, component by component. Only real numbers allowed.
• Select Symmetrize from the menu - the mass matrix will be automatically symmetrized.
• Choose Dirac or Majorana masses.
• Click the checkbox to add right-handed neutrinos.
• Select Diagonalize from the menu.
• Study the results.
• To study the consequences for observable phenomena in different part of the universe chose the appropriate menu item.

• Mass matrix is diagonalized correctly, up to machine accuracy.
• Checks for the lab limits for masses, including Majorana mass.
• Compares with some neutrino oscillation searches
• Makes predictions of solar and atmopsheric neutrino fluxes and compres them with the experimental results.
• Vacuum oscillation for solar and atmospheric neutrinos.
• MSW effect. Drawing is multithreading -you see the plot appearing gradually as more points are computed. Accuracy better than 10 %.
• Relic neutrinos and dark matter.
• Supernova neutrinos - observable spectrum, implications to explosion and nucleosynthesis.
• Right-handed neutrinos. Try also see-saw.
• Zee model
• Magnetic moments
• Neutrino decays

Some explanations

• The three boxes give the electron neutrino disappearance probability, the probability for the conversion from muon neutrino to electron neutrino, and the conversion probability from the muon neutrino to tau neutrino, as a function of L/E.
• The boxes correspond to the sensivity of the experiments. The vertical lines show approximately the range of L/E that can be explored, and the horizontal line gives the bound for the average probability. In most experiments the sensivity is not linear in L/E, so that within the explorable range the true bound may be somewhere below or above the depicted line. Nevertheless, if all your points are well above or below the boundary line, you may assume that your model is forbidden or allowed. If the points are close the line, you should take this as an invitation to investigate it in more detail using the criteria published (or unpublished) by the experimental collaboration.

• The black crosses are the predictions (with oscillations), and blue or yellow bands are the experimental results, with one sigma errors.
• The threshold energies of solar neutrino experiments are displayed as different shadings in the solar neutrino spectrum graph.
• The blue and white rectangle is the status bar. The experimental results are displayed when all points are calculated. The first curve is not averaged, hence it may display some articifial oscillatory features.
• A crude Chi squared is given.

• The first plot is the double ratio as a function of L/E measured in SuperKamiokande.
• The next plots compare the simulation with the experiments.
• The black crosses are the predictions (with oscillations), and blue or yellow bands are the experimental results, with one sigma errors.
• A crude Chi squared is given.
• Uses a distorted Honda et al model for the atmospheric flux. This is not very well adapted for this purpose, but the experimental groups have not revealed the details of the calculations and predictions they use.

• The plot gives the neutrino fraction in the universe relative to the critical density, that is the usual omega, as a function of the normalized hubble constant.
• Neutrino decays are taken into account
• The black lines show omega for h=67 ± 6, and the green area is the respective two sigma region.

• The central plot gives the neutrino spectra observable at terrestrial detectors. The three curves correspond to electron neutrinos, electron antineutrinos, and the average of all active neutrinos (for neutral currents). Note logaritmic scale.
• The left canvas displays the electron fraction at the distance of 1000 km.
• The right canvas displays qualitatively the effects on the power of the explosion.
• The rightmost canvas is not activated - it should display the energy loss from the supernova core, compared with the standard case.
• Be aware that the results are based on a simplified astrophysical model. Other models may give different results - the chosen model may not be any better than any other model. Note also that the neutrino spectra and the stellar profile are not constant - the displayed results give a snapshot at some epoch within the first second after the bounce.
• feedback effects not accounted for - conversions from electron (anti)neutrinos to sterile neutrinos may be erratic for masses above eV scale.
• If you understood the above, you already know that the results are only order of magnitude estimates.

Performance

The code is designed to be loadable class by class. It should start running when the first class is loaded, and the rest of the classes may be loaded on demand. Nevertheless, many systems load all classes upon initiation of the program, even if those classes are never needed (Probably this feature is related to Just In Time compilers). At best, this improves the performance, since new classes are already loaded. At worst the loading of unnecessary classes takes lots of time before the execution can start.

Description of the code

User interface

Diagonalisation of the matrix

Inside the integration of the neutrino wave penetrating a star, a lighter first order diagonalization routine is used. Although it does not diagonalize the matrix completely, there will not be any accumulated error due to that.

Solar neutrinos

Matter effect is modeled by a numerical integration over the Sun. The code has been optimized for speed rather than accuracy. It has been designed for a numerical accuracy of 2 %, and at least for solar neutrinos its accuracy is better than 5 %, for most parameters.

In the integration, the neutrino wave functions is divided to the absolute value and the phase. This allows to treat the absolute value accurately enough, while the evolutions of the phases can be computed by lighter accuracy.

The many component neutrino wave is always taken to be in the local eigenbasis of the medium. While the eigenbasis changes, the effective hamilton operator acquires non-diagonal components proportional to the derivative of the mixing matrix. Compared to the straight-forward integration in a fixed basis, the eigenbasis method provides better accuracy, since there is no unnecessary oscillation among the integration variables. Most runs require O(100) steps, though the penalty is that tediuos matrix multiplications have to be done at each step. Peculiarly, the code is fastest for full adiabatic conversions, while it is very slow for very non-adiabatic conversions by rapid change of the potential. As such cases lead to very small conversions, the code tries to detect abrupt crossing of the resonance, to pass it smoothly.

The MSW routine is run as a separate thread. The plotting is also its own thread. Unless you have a multiprocessor mahcine, the threads are not run concurrently. However, this provides the essential benefit of seeing how the integration proceeds, until all about 144 runs have been computed. Often the first points are enough to give an image what is going on. Later points add accuracy. Sometimed the solar screen is not updated regularly. To force the update, repress the solar neutrino button, or minimize and maximize the browser window, or do something similar, depenping on the platform.

The finite size of the neutrino production region is accounted for by taking an average of 17 different initial points. Angular distribution is still incomplete.

For the Sun and the solar neutrinos the models and data by John Bahcall is used. (BP 98)

The predictions for the experiments are calculated by computing the expected neutrino fluxes within the sensitivity of the experiments. The code uses tabulated cross sections and solar fluxes, sums over the energy spectrum, and takes the neutral currents into account in water detectors.

Other parts of the code

Hardware and software requirements

• Hardware:
  • color monitor with the resolution 800*600
  • powerful processor (P150 or like) and lots of memory (16-64, depending on OS)
  • mouse
• Software:
  • at least 32-bit multithreading operating system with a graphical user interphase
  • up-to-date Java 1.1 enabled web browser
  • optimized JIT compiler (especially for studying MSW effects)

The program runs also as a standalone application. Load masstoy.zip, unzip it into a directory MassToy and try
java MassToy.Masstoy, (in the parent directory). This procedure may be machine dependent, consult the documentation of your system.

Known bugs, misfeatures or limitations

• The 6-6-component of matrices is not displayed. Probably a bug of the compiler.
• Neutrino conversions in supernova may freeze or diverge for certain parameters. (probably fixed in 0.39/0.40)
• In some rare cases the MSW routine may miss or mishandle a resonance - occurs mostly for complicated 4 flavour supernova simulations, resulting in weird neutrino spectra.
• If you do not have three massive neutrinos an exception will occur. (fixed in 0.41)

• Atmospheric neutrino model very poor - the code has been calibrated with some artificial parameters.
• No CP-violation - only real matrices allowed.
• Checks for many laboratory constraints not done yet.
• Astrophysical constraints are rather crude.
• Phenomena in the core of supernovae not yet studied. Also other supernova code is very primitive.
• Early universe not simulated either.
• No links to references.
• Feedback effects in neutrino conversions ignored.
• No matter effect for solar or atmospheric neutrinos passing earth.
• Day night effects for solar neutrinos not simulated.
• Some symbols inconventional or inexistent, since few systems support full Unicode.
• This is probably a feature of the operating systems, but many unix machines do not reload the java classes unless you reboot the computer.
• Printing does not work. This is a security feature of Java: applets loaded from the web cannot send anything to a printer.
• Probably does not work at all with some Microsoft products, because they contain too many bugs. Sorry, but I cannot do anything for this before Bill fixes his part.
• Does not take majoron (or any other scalar) couplings as input
• The statistical analysis (chi squared) is very primitive and not compatible with other published values. For example it does not treat the (correlated) systematic errors correctly.

The applet has been tested in the following platforms (not necessarily the newest version):

• Java applet viewer (Java 1.1.6) under OS/2 Warp version 4: works well and looks fine
• Netscape 2.02 under OS/2 Warp version 4 : works flawlessly, runs very fast and looks fine
• Netscape 4.05 beta under OS/2 Warp version 4 : the browser crashes with all Java applets .
• Netscape 4.04 under Linux: Works and looks almost OK. Via X terminal very slow.
• Netscape 4.04 for Windows 3.1: Works, but is dead slow. Graphics occasionally distorted.
• Netscape 4.05 for Windows 3.1: OK but very slow.
• Netscape 3 in PowerMac: works, but is very slow.
• Microsoft Internet Explorer 3.0 for Windows 3.1: Java crashes by start.
• Netscape 4 at Silicon Graphics: started OK but freezed at some point.
• Microsoft Internet Explorer 4 under Windows 95: works quite well and fast. Minor defects on the look and feel.
• Netscape 3.01 under Linux RedHat4.1: works

The applet looks very ugly now. The ugliness is a way to get around of bugs or features in some systems. (Do not believe the marketmen who claim that Java is a platform-independent language. Nothing is idependent on the platform, nothing, believe me.)

Some tips and hints

• You have Java correctly installed in your system.
• You have a web browser that supports Java (Read the documentation - if it does not explicitly mention Java, it does not support Java.) Recent versions of Netscape are good.
• You have not turned on disable java in options or preferences of the browser.
• If it fails to run in your web browser, load the zip file and run it either as a standalone application (java Masstoy or in your applet viewer (applet tt-mass.html, you need to save tt-mass.html in your disk).
• If the performance is very poor, check whether you have an outdated version of Java.
• Your client may be still loading the program over the network - the code is long and the internet it slow.

Release notes

• 0.01: first version released to the net. Diagonalised the mass matrix.
• 0.02 - 0.11 : early evolution versions, added more features.
• 0.12: fixed solar neutrinos.
• 0.13: minor updates on data, some corrections of the code and redesign of the look.
• 0.14: right-handed neutrinos included; omega-h-plot for dark matter; bugs corrected.
• 0.15: included neutrino conversions in supernova; MSW code refined.
• 0.16: corrected a persistent bug in MSW-code, small improvements here and there.
• 0.17: minor improvements here and there, some enhancements of the user interface, and cleaning of the code.
• 0.18: major changes in the interface: the Applet runs now in a separate Window, and it is controlled by menus.
• 0.19: minor improvements in the interface. Removed an eternally appearing exception.
• 0.20: Changes in the internal structure - supposed to load faster. Minor changes in the interface.
• 0.21: Some restructuring of the code. Input enhanced - Zee model included.
• 0.22: Cleaning of code. Added electromagnetic properties. Some enhancements of input - demo mass matrices (quite arbitrary). New version (bug fix) of the Java compiler used (still 1.02 level).
• 0.23: Can be run as a stand-alone application. Solar neutrinos refined. Group exception fixed.
• 0.24: Some bugs fixed (matrix diagonalisation, supernova jams, nutau expts). Enhanced electromagnetic properties. More demo values added. Some minor modifications of the interface.
• 0.25: Added neutrino decays and status bars for solar and supernova computations.
• 0.26: Some bugs corrected. Added comparison to Chooz.
• 0.27: Lots of bugs corrected, interface enhanced.
• 0.28: Some minor bugs corrected, code restructured (little effect for end-user). Compiled with a new Java 1.1.4 compiler. Code still at Java 1.02 level.
• 0.29: Minor bugs corrected, major rearrangements of the code. Added an inoperative plot.
• 0.30: Substantial improvement on the performance - starts much faster, loads classes in a thread.
• 0.31: Major improvements on the performance during the initialisation. Now starts 'immediately', after loading the first classes. Actual efficiency depends on the system, and the state of the network, though.
• 0.32: Corrected neutrino decays. Now calculates the relic densities with all decay modes, including three neutrino decays. Added an empty canvas for radiative neutrino decays.
• 0.33: Minor bugs corrected. Major changes in code with no effect for the end user.
• 0.34: Major parts of code rewritten, but the only visible effect was the appearance of new bugs. Never released to the public.
• 0.35: Corrected the bugs. MSW routine rewritten for better performance. Autodocumentation.
• 0.36: Solar neutrino experiments fixed and updated to results reported at Neutrino 98. Compiled with Java 1.1.6.
• 0.37: Solar neutrinos refined. Added a primitive chi squared analysis.
• 0.38: Atmospheric neutrinos completely recoded, with a comparision to SuperKamiokande. A minor solar neutrino bug fixed.
• 0.39: Fixed a bug on MSW conversions, appearing for supernova neutrinos. Atmospheric neutrinos refined.
• 0.40: MSW routine enhanced - still far from perfect.
• 0.41: Fixed an input bug. Tuning of MSW continues.
• 0.42: code migrated fully to Java 1.1 level. Some changes in the user interface, more to come. Interchanged the notation for experimental and theoretical values at atmospheric neutrino plots.
• 0.43: more visual changes in the user interface. Several bugs fixed in input and display.

• Intelligible help features and explanations.
• Better predictions for the atmospheric neutrino fluxes.
• Will handle neutrinos in early universe, especially the effects on nucleosynthesis. Do not hold your breath with this, however, it is a more elaborate task than any of the present contents..
• User interface will be redesigned.
• Consequences to structure formation
• Radiative neutrino decay and photon background
• More models for neutrino masses
• Exotic decay modes, e.g. majorons.
• Better simulation of supernova dynamics.
• More powerful and more accurate MSW routine.
• The code will be made more intelligible, to allow it to be maintained more easily, and more compact, to allow faster loading over the network.

Feedback