Subject: Muon Propagation
Date: Thu, 30 Nov 2000 23:56:13 +0100

muon montecarlo code written in java version 0.01

The code:

1. compiles
2. runs
3. contains all foreseen cross sections

The main purpose of the code is to calculate final energy of the muon with the
given initial energy after some known distance, or to say where exactly it
disappeared if it didn't reach the final point located at a given distance
form the initial point.

Running of this code is *not* for the weak of heart. Please do not start it
unless you have a couple of hours to spare (at least on my machine).

As it is given, it will propagate a total of 2 (two) muons with energy 10^5
Mev to a distance of 10^4 cm. Each muon will be subject to decay, ionization ,
bremsstrahlung, pair production and photonuclear losses as well as knock-on
stochastic energy transfers to electrons and photons arising in the above
mentioned processes.

Although i have sorted out most of the notational and purport questions, i
still have a couple, including the following:

1. what is M in formula (8) of the cross sections' paper?

2. do we take it seriously?

3. If yes, do we take into account the binding energy of the nucleons in the
nucleus?

4. Almost in every cross section the energy lost is the energy gained by the
main knocked particle (electron, photon, epair, or nucleus). This most likely
leads to systematic error - energy lost being smaller than it really is. Is
there a reference that calculates distribution of energy between main particle
and those of secondary importance?

5. Where do i take delta (density correction) in the ionization formula from?

6. maybe something else.

Now there is the following work still to be performed:

1. Answer the above questions and implement their recommendations.

2. plot all cross sections and compare them with values from papers.

3. look at the plots and think of the possible variable changes in the
integrals to accelerate calculation

4. choose and implement parametrization scheme for each of the integrals
(except the tracking) that would allow the use of the program for the peaceful
purposes.


Subject: Muon Propagation
Date: Fri, 01 Dec 2000 00:06:33 +0100

>5. Where do i take delta (density correction) in the ionization formula from?

A small correction: from the formula given in the paper, but what is `m' in
this formula?


Subject: Muon Propagation
Date: Fri, 01 Dec 2000 05:48:57 +0100

version 0.01.01 of the muon propagation montecarlo code written in Java
(MPMCWJ)

The update fixes handling of an unusual condition in class Integral as well as
bug in the integrational limits in the photonuclear cross section. This, btw.
could be considered as the bug in the cross sectional paper: 3rd formula from
the top of the page 255 gives negative values for low enough energies (lower
than 512.68 MeV). Probably the formula is not applicable at energies that low,
but then we need to know exactly the cutoff energy, or if the contribution of
this formula from energies lower than cutoff is negligible, just do nothing.

Another correction:

>6. maybe something else.

6. what exactly is the expression for the dzi in Z*(Z+dzi) in the pair
production formula?

7. maybe something else.

in the todo list:

5. compare energies of some small set of muons with the results of a+bE
formula.


Subject: Muon Propagation
Date: Tue, 05 Dec 2000 04:34:29 +0100

I am thrilled to announce version 0.01.02 of the mmc. It was possible to
compare this version of the program with the tables from the yellow book
(1985). All energy losses are comparable to those in the book. Agreement is
within the first 2 digits in most cases. I have noticed, however, that
bremsstrahlung for the Hydrogen differs more, and the more, the smaller the
energy. E.g.

Energy, GeV	book		mine
1		17.41e-8	8.235856436249125E-8
10		3.173e-6	1.9318150603531618E-6
100		4.589e-5	3.664803882069739E-5
1000		5.786e-4	5.380685468381188E-4
10000		0.008635	0.008775320747892678

Is it known of works reporting similar deviations? Or is it more likely to be
due to the programming error?

This version is half the speed, twice the bugs. Or rather, half the bugs, but
one tenth of the speed of the previous version. Part of this (or all) is due
to more realistic settings. For the ongoing calculation in the Symphony
framework i set the energy of muons to 1TeV, and they are propagated through
1.5 km of ice.

Next step would be to improve the speed. By a lot. Really. A factor of
thousand in speed (i mean faster) would probably advance version to 0.02.


Subject: Muon Propagation
Date: Tue, 05 Dec 2000 22:57:04 +0100

Version 0.01.03 is out.

I was able to find the formula for the electron correction to the pair
production cross section in the "cross section" paper: at the bottom of page
255. From now on i will not dare say something is missing in there or
incorrect. So, this is implemented.

Another change is implementation of frejus rock. It is created by calling
Medium("Frejus Rock"); of the class Medium. Regular "rock" is now called
"Standard Rock".


Subject: Muon Propagation
Date: Wed, 06 Dec 2000 18:30:00 +0100

Version 0.01.04 of the mmc program is ready.

The main change was clearing up the code containing random number generations,
and putting comments describing the decision steps performed by the
propagateTo function in form of the debug messages. Medium class now contains
the string, describing the employed medium.

The next release will include parametrizations.


Subject: Muon Propagation
Date: Fri, 08 Dec 2000 20:50:00 +0100

0.01.05

And yet another update before v 0.02.

Structure of the program has changed significantly: there is now 3 subclasses
for each cross section. This should help the code's modularity and
maintainability.

Interpolate routine in the class Integral is updated with the new step
algorithm. A new class Interpolate was written and included in the alpha of
version 0.02. The Propagate code with the routines from this class is,
however, not yet reliable, so not yet released.

vCut (in Medium) is now a function. This allows for both constant vCut or
eCut=vCut*E settings.


Subject: Muon Propagation
Date: Tue, 12 Dec 2000 02:35:23 +0100

Na ... endlich. For your exclusive entertainment the new v 0.02 of the Muon
Propagation Monte Carlo Written in Java is brought out into the world. This
version features:

1. Greatly improved performance: Time of calculating 1 (one) event with all
parametrizations enabled is 0.25 seconds. The same with only epair
intermediate integral parametrized is 20 seconds. The same with no
parametrizations at all is 360 seconds.

The times given above increase for the eCut=const option enabled. All
calculations were made on my P3 892 MHz computer with JDK 1.3.

2. New not yet completely explored bugs: Some cross sections give negative
values outside there scope of applicability. Parametrizations sometimes lead
to very wrong results: one of the 2 included parametrization schemes (which is
supposed to be more precise) almost always fails to propagate even one
particle due to unsmooth behavior on the boundaries of the approximation. Some
routine checking for the boundary conditions could repair this.

3. There are now only 2 more integrals which have not yet been parametrized:
these are those that take the calculated cross sections and evaluate the path
length to the next interaction and energy at that point. These one-dimensional
integrals should be parametrized too.


Subject: Muon Propagation
Date: Wed, 13 Dec 2000 03:58:04 +0100

You are invited to enjoy v 0.03 of the Muon Monte Carlo!

New things:

1. Root finding in the parametrized cross sections was stabilized by
implementing a brand new substitution of the lost energy. Now results are much
closer to what non-parametrized version gives. To compare simply remove
reference to p.interpolate() in the New class.

2. This substitution solves a large number of problems that i've been hunting
down for the last 10 hours. The program now really gives results in real time
that are believable. Please find attached a plot that shows the energy
distribution of 10000 muons propagated through 300 cm of iron with initial
energy 1e6 MeV. You may compare this plot to the plot contained in the PDB
p.138 (1996, figure 22.13). It took 30 minutes to generate the muon set.
Fractional energy cutoff was chosen at 1.e-4. The plot with vCut=1.e-3 looks
somewhat different. It also took only 15 minutes to generate.


Subject: Muon Propagation
Date: Wed, 13 Dec 2000 14:12:58 +0100

This is an update to version 0.03.1.

A very serious bug was repaired in the Interpolate class that was severely
hindering the precision of the root finding interpolation. Now the precision
of that part is raised by many orders of magnitude without the help of the
FindRoot class.


Subject: Muon Propagation
Date: Thu, 14 Dec 2000 04:00:17 +0100

In this new 0.04 version of the MMC i have improved the following things:

1. Energy track and distance integrals have been fully parametrized.

1a. It turned out that one dimensional parametrization of these integrals had
awful precision, so i made it 2-dimensional. In the code implemented 100x10
array provides orders of magnitude better accuracy than 1000 element array
that i left out.

2. This has improved speed, but only by a factor of 10-20. Now if we could
find out how to estimate time that the program spends per routine, we could
try to optimize it more. Do we know people specializing in Java who could
explain how to do that? I have some ideas of how to optimize the code. For
example, the parametrization routine that finds roots calculates N=100
functions, each evaluation being a superposition of another 5-10. However,
only Ln_2 N + 5 = 6 + 5 = 11 function values are used. It would be nice to
know if the program spends a significant part of its time on this routine. If
so, it could be optimized another 100/11~10 times!

3. Fixed various bugs that were handicapping the calculation at small
energies. All unusual conditions that resulted in NaNs and too big to believe
energy losses have been fixed (at least in my test run).

4. Test run was made for Frejus Rock, 1.e5 particles with energy 100 TeV were
generated and propagated through 300 m. According to your formula a+bE the
average final energy of the particles is 74820 GeV. The average from the plot
is 71000 GeV. The calculation took 17 minutes. Files a and b differ in
binning: a has 100 bins and b has 500. Are the effects that we see at closer
resolution normal?

5. I do not see why not try a sample of Frank's data today. I only need to
include file i/o option in the code. Rather, the code is complete, but the
programs that calls functions from this code needs some i/o software
implementation.


Subject: Muon Propagation
Date: Thu, 14 Dec 2000 15:09:39 +0100

In this new version 0.05 i have optimized the interpolate root finding routine
as discussed in the previous memo. It turned out that it was an important
optimization: the test run that took 17 minutes now runs in 5 (plus 45-50
seconds for creating parametrization profiles in each case). Now i am out of
ideas for optimizations. If necessary, one would have to hunt for the next
major culprits that eat too much time, and optimize those, if possible. I do
not remember any possible candidates, however.

This version should be considered as pre-release, with only minor things still
being tweaked, unless something major (a bug or bugs) comes crashing
everything down.


Subject: Muon Propagation
Date: Mon, 18 Dec 2000 00:49:05 +0100

On the way to (and from) London i have thought of the few things that could be
improved. Some of them i have just implemented. So here is v 0.05.1:

1. Interpolate is faster: the test run now takes only 3.5 minutes. This was
still achieved without sacrificing the clarity of the code.

2. Comments are added to all uncommented functions (i don't claim these
comments are useful).

3. it is now possible to enable only some of the parametrizations by passing a
string variable to p.parametrize(w) that contains the names of things to
parametrize. w="all" will parametrize everything, just as before.


Subject: Muon Propagation
Date: Mon, 18 Dec 2000 14:53:07 +0100

v 0.05.2:

1. Photon-nucleon cross section parametrization based on the table of values
now uses class Interpolate, that means more precise interpolation. It can be
enabled by setting p.s.n.measured=true.

2. Precision of photonuclear cross section parametrization was raised to the
same level as precision of the other cross sections.


Subject: Muon Propagation
Date: Wed, 20 Dec 2000 01:34:59 +0100

Please find a new v 0.06 of mmc. How do you like this name, btw? The changes
are:

1. This version is faster than the previous: the test run takes now only 1
minute 50 seconds (plus 1 minute for initialization). I have to move to a
bigger test run now, since this one finishes too fast. The improvement in
speed occured when i removed some string functions that were preparing the
string to be output on the screen, even though the output itself was disabled.
Apparently, java string functions are not too efficient.

2. New class "Output" was created. Now it's possible to choose between F2000
and default outputs. As follows from point 1., enabling any of these outputs
(to see the history of particle propagation) will slow the program down 2-3
times.

3. Particle and Propagate classes were reworked. Now it is
angle-dependence-ready. All calculations are done carefully in 3 dimensions.
Adding an angle distribution (when the formula is known) should be a snap.

4. All vital classes were moved into a package called "mmc".

The new test with 1 mil. particles took only 18 minutes.


Subject: Muon Propagation
Date: Sun, 24 Dec 2000 05:38:31 +0100

Introducing v 0.07!

New features:

1. Amount of static variables is reduced to a minimum, which allows several
instances of class Propagate to coexist simultaneously.

2. Added classes Frejus and Amanda. First simplifies handling of the data
tables for comparison with Frejus data. Second implements a simple solution
for the f2000 format handling and is designed to replace dedx in the AMANDA
software chain.

3. A little debugging of Propagate and Particle allowed for more reasonable 3d
model.


Subject: Muon Propagation
Date: Mon, 25 Dec 2000 03:39:06 +0100

This Christmas brought to you by Dima co. R (Copyright Wuppertal, 2000):

mmc v 0.08!

1. Once again, a rewrite of the Cross section classes, with the aim of
improving the class structure (readability and maintainability). Now the only
static variables are in the Output class, where they belong.

2. A brand new feature: table save and restore. Simply put the proposed
filename (best try "") as the second parameter of the interpolate function,
and the second time you run the program, parametrization time will be reduced
by a lot (20 times in my test run, but depends on how large the tables and
precision of the parametrization are).

This should likely conclude the introduction of brand new features with every
new version stepping. One thing that should still be done is a more precise
consideration of 3 regions in the Amanda class. At the moment only a crude
model is used, where the regions are separated by top and bottom of the
detector.

In the yesterday's version (0.07) the file routine in the Frejus class was
improved, and now processing of the Frank's Frejus data file takes only 2
hours - just what he mentioned for the MUM code. One should take into
consideration, however, that MUM code was run on a 533 MHz Alpha processor,
while mmc was run on a potentially faster (and possibly by a lot) Celeron 892
MHz.

Run Frejus as follows: time cat dedx_out.txt | java Frejus | sed '1,/---/d' >
dedx_out.out


Subject: Muon Propagation
Date: Sat, 27 Jan 2001 18:00:00 +0000

Update from the South Pole.
To generate a set of data (for frejus type analysis) run

awk 'BEGIN {for(i=0;i<100000;i++) print 1.e5*exp(log(rand())/(1-3.7)),
1.e3*(3+2*rand())}' > dedx_out.txt

This will produce 100000 particles with E^-3.7 spectrum at the surface that
are to be propagated to the depths of 3000-5000 meters. After you run Frejus
on the dedx_out.txt file, run cat dedx_out.out | awk '{if($3>.3) print $2}' >
out to select the events that reach the given depth. Then you can plot number
of events vs. depth. This is the "frejus" type test. As of today this test
gives exactly the same results for MUM as for MMC. The execution time for MMC
is 737 seconds (1000000 events) with romberg parameters set to 5 (default
setting). When decreasing romberg parameters to 2 in all parametrizations,
calculation time improves by a factor of 3 and takes only 248 seconds. For
comparison, MUM takes only 71 seconds to finish the same run (with 18 seconds
necessary for initialization it takes 89 seconds). The reason for the bigger
calculation time of MMC is that for every interpolation step it calls a
function that interpolates in a cycle. It even calls another function for 2
dimensional interpolations. In addition, many parametrizations use exp-log
substitutions. This is done for generality and code simplicity. MUM, on the
other hand, does all interpolations inline, in about 4 addition operations
altogether. Execution times are given for the P3 866 MHz computer.


Subject: Muon Propagation
Date: Sun, 28 Jan 2001 18:00:00 +0000

Update from the South Pole: mmc v 0.08.1

3 regions in the Amanda class are now treated according to their definition:
the first region is outside the detector volume, where the particle (muon)
propagates from the ice surface to the detector, the second is between the
initial entry of the muon into the detector volume up to the point when it
leaves the volume, and third region describes the particle after it leaves the
detector until it stops. In case the particle misses the detector volume
altogether, the complete history of the particle is considered as happened in
the third region. Also the correct resequencing of the track numbers was
implemented. The particle parent information is kept only for the secondaries
created by this mc, however. The program also leaves a history line.


Subject: Muon Propagation
Date: Sun, 28 Jan 2001 23:00:00 +0000

Update from the South Pole: mmc v 0.08.2

The correct formatting of the doubles was finally implemented. Now the user
can enjoy the output being free of the crazy numbers like 0.9999999997.
Special care was taken to make sure that the execution time increases by as
little as possible because of the change (2% increase was observed in a one
minute test run).


Subject: Muon Propagation
Date: Mon, 29 Jan 2001 23:00:00 +0000

Update from the South Pole: mmc v 0.08.3

Another change of the double number printout. This time it's made more uniform
and every number can now be represented by up to 7 digits (and E?? part, if
necessary, in the scientific notation).


Subject: Muon Propagation
Date: Sat, 24 Feb 2001 17:00:00 0800 (PST)

mmc v 0.08.4

It was found that the application of the double number printout function gives
incorrect results when used from inside the java-applet MPMCWJ (to be used
with SYMPHONY), so it was disabled there. Also, it appears that this function
gives locale-oriented output, so that e.g. in Germany decimal point is a
comma. This makes the following processing of data more complicated, since
most of the shell utilities not to mention fortran will choke on the numbers
containing commas. To always get US english standard output, set the variable
LANG to en_US in the shell from which java program is started. Otherwise, if
you don't mind having long numbers like 0.9999999997 (standard java output),
just delete all instances of "Output.f" in the output functions of the calling
class (e.g. Frejus.java).

It was found that some of the entries of the parametrization tables had
negative values. The error was reduced to the minimal energy used during the
parametrization being smaller than the minimal energy p.low. It was due to the
minimal parametrization energy being set to at most twice the mass of the
muon, while p.low was set to a higher value (450 MeV). The error was corrected
by setting the lower parametrization energy to exactly p.low. Since the values
of the parametrization tables for energies lower than p.low are/were never
used, this correction should not affect the previous results.


Subject: Muon Propagation
Date: Mon, 05 Mar 2001 18:00:00 0800 (PST)

mmc v 0.08.5

To correct for the low-energy deficiency found in the final energy plot of the
muons with constant initial energy (found by comparing non-parametrized
version of the program with the parametrized), substitutions used in the
parametrization formulae were changed, and as a result, simplified. Also the
"rationalY" variable was set to true, which improved the precision by at least
another order of magnitude. Extensive check of the precision of cross section
parametrizations was made (at 4 energies 10, 1e3, 1e5 and 1e9 TeV), and it was
shown that the overall precision improved by 2-5 orders of magnitude.

Also, scripts acom and ammc were included for compilation and running of the
Amanda.java program.


Subject: Muon Propagation
Date: Wed, 28 Mar 2001 19:00:00 0800 (PST)

mmc v 0.08.6

vMin was introduced for the ionization. This replaces the made-up value of the
lower limit in the integration of the inelastic electron bremsstrahlung
correction to the ionization energy losses. This should not change the
previously performed calculations by more than 1.e-6 - 1.e-7.

A presentation containing formulae used in this program and some analysis
conclusions, presented at the Bartol meeting is now available at the mmc
homepage.


Subject: Muon Propagation
Date: Fri, 30 Mar 2001 12:00:00 0800 (PST)

mmc v 0.08.7

Amanda class now understands command-line options. Type "java Amanda -help"
for a list of them. At the moment you can set the dimensions (length, radius
and depth) of the detector. Scripts ammc and acom were modified accordingly
and unified. Now to compile the program run "ammc -compile", and to execute it
run "ammc -run". For a list of available options in the run mode, use "-help"
option.

A fail-safe mechanism was implemented to avoid using the stale corrupt data
files and recalculate them on the fly.


Subject: Muon Propagation
Date: Wed, 18 Apr 2001 19:00:00 0800 (PST)

mmc v 0.08.8

A weird bug was determined: after some number of input lines (14000) the
program fails to pass the first argument of the initDefault function (time)
along to the function correctly. The argument changes right after the function
call, before executing the body of the function. It is possible to correct the
problem by introducing the dummy first argument (int igen) and then calling
this function with some integer (e.g. 1) as the first argument. I also found
that introducing a special line (with the comment //Java bug) gets rid of the
problem. At this time it looks like a compiler (or jre) problem. Also,
Amanda.java was cleaned up and optimized a bit.

A small bug was found in a Ionizationloss class: an ieb correction contained a
typo (thanks, Ped). In principle it could have affected the results. The
effect was negligible in our tests, however.

ammc script was changed to process Frejus program as well as Amanda. Call ammc
with an extra parameter "-f" to compile or run Frejus class.

A set of two values of radiation logarithm constant B used thus far in
bremsstrahlung and pair production corrections (for H and all others) was
replaced with the table of pre-calculated values for most elements.
Calculation of B as well as B(prime) was moved into the Medium class.


Subject: Muon Propagation
Date: Wed, 16 May 2001 22:00:00 0800 (PST)

mmc v 0.09

Following a suggestion by Paolo, an option to record a user line is
introduced. Just add "-user" to the list of options to enable. Similar to
mudedx, the user line format is "USER_DEF mpmcwj-energy E_CPD E_IN E_OUT CDP_X
CDP_Y CDP_Z Z_IN Z_OUT E_INI". The values in the line are evaluated for the
highest energy muon only. Coordinates are always evaluated. If an energy is
not evaluated (e.g. the muon disappeared in the first region, E_OUT is not
evaluated), it is set to zero. If it is negative, it shows the z component of
the distance from the region end to the point where the muon disappeared with
the minus sign. Otherwise the muon survived and its evaluated energy is
recorded.

As a result of some rewrite of Amanda class the java bug mentioned above
disappeared and does not seem to need any artificial correction. Another bug
was revealed. A decision whether a particle reached the final z or disappeared
is based on a comparison of the type z==z. A correction to account for the
possible deviation due to the finite computer precision was implemented.

A change is made to the function propagateTo: now if the returned value is
negative, it shows the z component of the distance from the final z to to the
point where the muon disappeared. Function propagateTo was also overloaded: if
a third argument, containing a value of some zc is added, the following call
to a function getPropEc will give the value of energy of the muon at that zc.
This zc should lie on the particle path before z, otherwise the result is
undefined.


Subject: Muon Propagation
Date: Sat, 19 May 2001 17:00:00 0800 (PST)

mmc v 0.09.1

Another change to the definition of the propagateTo function and all its
derivatives has occurred: now if the returned value is negative, it shows the
distance traveled to the point of disappearance. It seems to be an easier and
more precise way to describe particle location in the 3d model. Consequently,
definition of the output by Frejus class has changed, as well as definition of
energies in the user line produced by Amanda class.

It is now possible to generate java manual pages by running ammc script with
an option "-manual". Manual pages will be put into the "manual" directory.
Also, an index.html file is created and put into the main directory.


Subject: Muon Propagation
Date: Thu, 31 May 2001 15:00:00 0800 (PST)

mmc v 0.09.2

ammc script was substantially changed: it now works with older versions of sh,
on pc's and alpha's. It also tries to find the latest version of java in a
pre-defined set of directories. If your java distribution is not in it, add it
to the set and let me know. I will modify the set of directories to include
any general locations of java. ammc will report and check the found version of
java when called without parameters. Only versions 1.2.2 and higher have been
tested. Version 1.1.8 will not work. The script will attempt to notify you of
insufficient version of java by displaying appropriate warnings.

All standard output statements of the java files in the mmc directory were
changed to standard error output statements. Those not directly related to
interesting output of classes Amanda.java and Frejus.java were changed in the
same way. This simplified handling of auxiliary output, which is now directed
to the standard error output. A line containing some information about the run
is output at the end of Amanda execution. This also simplified ammc script
somewhat. It will now give an error message and return the exit code 1 if
running or compilation failed.

Treatment of the corrupt data files improved. It is now compatible with the
new java v. 1.3.1. Exception class mmcException was made public and is used in
Amanda and Frejus classes for reporting an input error as well as for the
parametrization table exceptions. Format of the parametrization table files
was changed: data is saved in a different order than before. The tables from
the previous versions must be deleted and generated with the current version.
A failure when handling a corrupted table that fails when epair cross sections
are read was repaired. Now it should be possible to run interpolate function
several times during one execution (e.g. after an interactive change of mc
settings).


Subject: Muon Propagation
Date: Sun, 10 Jun 2001 00:00:00 0800 (PST)

mmc v 0.10

Substitutions in parametrizations of stochastic components were reworked,
which resulted in a better precision of interpolation routines. Integrations
inside classes Propagate and CrossSections were changed to be done with log
substitution, and parametrization model for them was changed to 1-dimensional.
Precision of these integrals and parametrizations was increased substantially.
Class TestPropagate was modified to allow for easy check of the precision of
the parametrization routines. Run "ammc -test=[1 or 2] to execute one of the
two checks: first of the parametrizations of the cross sections, or second of
the parametrizations of the tracking integrals.

A high fidelity version of the program can now be easily generated with "ammc
-hifi". This will, however, lead to a program that takes much, much longer to
initialize (on my P3-850 regular mmc takes 2.5 min, and hf mmc takes 70 min).

Particle propagation code in Propagate.java was simplified without changing
the tracking algorithm. A cosmetic change was also done in class Integral.

Artificial cutoff of 10 GeV in Epairproduction was removed, even though the
precision of the formula for the epair production is not guaranteed to give
accurate results below 10 GeV. This revealed a bug in the class Integral - if
the integral is zero, the routines rombergIntegrate* were getting stuck at the
precision evaluation. Now, however, for some non-zero functions with a lot of
bad luck a loss of precision in the integral evaluation may occur.

An electron produced by muon decay is now output with the correct energy. It
is also possible to consider decay of the stopped muon. Calling Amanda with
the option "-sdec" will allow this.


Subject: Muon Propagation
Date: Mon, 25 Jun 2001 01:00:00 0800 (PST)

mmc v 0.11

Interpolate class was augmented by log substitutions, which were taken out
from the main code for energy substitutions. Both arguments and function value
log transformations are available.

ammc was augmented to compile and run other programs. Also compile all option
is there. Cleaning without sources will now not delete the program executable.

A precise timing for slow particles is now available. Set p.exactTime=true to
enable. The program was also successfully tested with the p.low value set to
the muon mass. This means that particles can be tracked precisely until they
decay (not just disappear in the definition of the program).

An option to enable some continuous energy loss randomization is introduced.
It is based on an assumption that the probability to lose energy e at small
fractional losses goes as 1/e. To enable, set p.contiCorr=true.


