Page MenuHomeHEPForge
Files F11221346

README
No OneTemporary
Actions

README
View Options

Program: SecDec
Authors: Jonathon Carter, Gudrun Heinrich
version 1.0.1
---------------------------------------------------------------------------------------
INSTALLATION:
./install
Prerequisites:
Mathematica
perl
Fortran compiler
----------------------------------------------------------------------------------------
USAGE:
0) change to the subdirectory loop/ or general/, depending on what you would like to calculate
1) Set the desired parameters in param.input and define the propagators etc. in Template.m
you can also rename param.input into [myparamfilename] and Template.m into [mytemplatename],
and move them to [myworkingdirectory].
2) Execute the command './launch' in the shell
(or 'path_to_launch/launch' if the launch script is called from a different directory).
this will launch the following perl scripts:
makeFU.pl (loop only):
constructs the integrand from the propagators and indices given in Template.m
decompose.pl:
launches the iterated sector decomposition
subexp.pl:
launches the subtractions and epsilon-expansions
and steers the numerical part
OPTIONS:
If a different parameter or template file is to be used,
use the options
./launch -p myparamfilename -t mytemplatename.
If these files are in a subdirectory, use
./launch -d myworkingdirectory -p myparamfilename -t mytemplatename,
or, from myworkingdirectory, use
path_to_launch/launch -p myparamfilename -t mytemplatename,
with 'path_to_launch' the (absolute or relative) path
to SecDec/loop or SecDec/general
3) a) if the calculations are done sequentially: (no batch system used)
The results will be collected automatically (via results.pl).
The output file will be displayed with your specified text editor,
The results are also saved to the files
graphsubdir/graph_pointepstothe*.res, graphsubdir/graph_pointfull.res,
where graphsubdir is the directory you defined in param.input
3) b) if using a batch system on a cluster:
i) default batch setup (PBS):
When all jobs have finished execute the command
'./results.pl [-d myworkingdirectory -p myparamfilename]' to collect the results
ii) user-defined setup:
manually edit perlsrc/makejob.pm and perlsrc/launchjob.pm (required) to be compatible with
your batch system syntax.
To ensure the maximum number of jobs allowed in the queue is not exceeded,
manually edit perlsrc/makesub.pm
(optional - if not done, max jobs allowed = infinity).
This writes the desired syntax to the scripts subdir/graph/job[polestructure], which are
launched automatically by subexp.pl (or finishnumerics.pl).
The submission files for numerical integration are created at
subdir/graph/polestructure/epstothe[o]/polestructure.[o].[ni] or
subdir/graph/polestructure/epstothe[o]/[nv]/polestructure.[o].[nv].[ni],
where [o] is the order of epsilon, [nv] is the number of integration variables (only when IBP used)
and [ni] labels which executable (intfile[ni].exe) is to be run.
these are launched by subfile.pl in the same directory, which is run automatically by
perlsrc/polenumerics.pl, or perlsrc/finishpolenumerics.pl
When all jobs have finished type './results.pl [-d myworkingdirectory -p myparamfilename]'.
4) To remove intermediate auxiliary files after completion of the calculation, type './launchclean[graph]'.
USEFUL ADDITIONAL COMMANDS:
'perl finishnumerics.pl [-d myworkingdirectory -p myparamfilename]':
if the 'exe' flag in 'param.input' resp. 'myparamfilename' is set < 4, this
will complete the calculation without redoing previous steps.
Then execute the command 'perl results.pl [-d myworkingdir -p myparamfilename]'
to collect and display the result as above.
'perl justnumerics.pl [-d myworkingdirectory -p myparamfilename]':
to produce results for a different kinematic point: (if fortran files f*.f have been produced already)
change the point name and the numerical values for the masses/invariants in the parameter file
and then execute the command
'perl justnumerics.pl [-d myworkingdirectory -p myparamfilename]' to produce numerical results
for different points in phase space
(it skips the mathematica subtraction+epsilon expansion step which can be done once and for all,
as the kinematic variables at this stage are still symbolic).
Then type 'perl results.pl [-d myworkingdirectory -p myparamfilename]'
to collect and display the result as above.
'./launchclean[graph]':
called with no arguments it removes intermediate perl scripts, makemakefiles, .o files, *sf*.f, executables,
and where applicable job submission files, but leaves the fortran files created by Mathematica,
so that different numerical points can be calculated without rerunning the Mathematica code.
called with the argument 'all' (ie "./launchclean[graph] all"), it removes everything except the *full.res file
-------------------------------------------------------------------------------------------------------------
STRUCTURE of the program:
-------------------------------------------------------------------------------------------------------------
SecDec/ contains 5 subdirectories: loops/, general/, basesv5.1/, Cuba-2.1/, doc/
subdirectory basesv5.1 contains the BASES library for the numerical integration,
subdirectory Cuba-2.1 contains the Cuba library for the numerical integration,
doc contains documentation (an index created with robodoc is available by loading
masterindex.html into a browser)
subdirectories loops/ and general/:
the input files to be edited by the user are param.input and Template.m
everything else is steered automatically by perl scripts;
there are 4 main perl scripts in the loop case, resp. 3 in the case of general functions,
which either launch Mathematica code stored in src/ or
launch other perl scripts stored in perlsrc/
the main perl scripts are
makeFU.pl: needed for loop integrals only;
constructs the integrand from the propagators and indices given in Template.m
if you would like to define the functions U and F manually, edit FUN.m
in the graph subdirectory and skip the makeFU.pl step
decompose.pl: launches the iterated sector decomposition and writes the files 'graphsec*.out'
for each pole structure
subexp.pl: depending on the 'exe' flag chosen in param.input:
exe=0: -writes the mathematica files subandexpand*.m for each pole structure
which serve to do the symbolic subtraction, eps expansion (with IBP where applicable),
and for writing the fortran files.
- also writes the scripts 'batch[polestructure]' which serve to launch the symbolic subtraction,
eps expansion (with IBP where applicable), writing the fortran files and the numerical integration
- if a batch system is used, it writes the submission files 'job[polestructure]' which are used
to launch 'batch[polestructure]'
- use this option if you would like to run different pole structures separately on different
machines/cores. In this case an individual pole structure runs sequentially on a single core,
but different pole structures can be run in parallel. Set the 'job submission' flag
to 0 (single machine). To run a given pole structure, type './subdir/graph/batch[polestructure]'
uses: templates perlsrc/batch and src/subexp/subandexpand.m
exe=1: (in addition to the above)
- launches the scripts 'batch[polestructure]', which launches subandexpand*.m
- subandexpand*.m will create subdirectories for each pole structure (via formfortran.m)
and write the fortran functions there
exe=2: (in addition to the above)
- creates all the additional files needed for the numerical integration
by launching polenumerics.pl for each pole structure
uses:
polenumerics.pl:
for each order (and, when IBP is used, each number of variables)
in the given polestructure it calls preparenumerics.pl;
preparenumerics.pl:
writes the sf, intfile, makefile, subfile.pl, make.pl for the given
polestructure, order, number of variables in the corresponding subdirectory.
exe=3: - compilation is launched (via make.pl) to make the executables
exe=4: - executables are run (via subfile.pl)
results.pl:
- scans through the subdirectories, picking up all necessary result files
- reruns/resubmits any which are absent;
if any results files are unfinished, it flags this up and suggests how this problem could be solved;
- collects the results, generates and uses the appropriate prefactors and
writes the results to files subdir/graph/graph_pointepstothe*.res and subdir/graph/graph_pointfull.res;
when a text editor is specified in param.input, this is used to display the results.
uses: perlsrc/prefactor.pl, perlsrc/mathlaunch.pl, perlsrc/getinfo.pm
subroutines called by preparenumerics.pl:
they all write auxiliary files needed for the numerical integration to the subdirectory
'graph/polestructure/epsilonorder/':
writefiles::makeint:
writes the main Fortran files *intfile*.f.
code found in perlsrc/makeint.pm
writefiles::makesum:
writes the fortran files *sf*.f which sum over subsector functions before integration.
code found in perlsrc/makesum.pm
writefiles::makejob:
writes the job submission files (in batch mode only). The user should edit the code in subroutine 'gouserdefined'
in the perlsrc/makejob.pm to be compatible with their batch system.
writefiles::makemake:
writes the Makefiles *make*file.
code found in perlsrc/makemake.pm
writefiles::makemakerun:
writes the scripts *make.pl which launch the compilation.
code found in perlsrc/makemakerun.pm
writefiles::makesub:
writes the scripts *subfile.pl which launch the executables.
code found in perlsrc/makesub.pm
finishnumerics.pl:
checks the value of the 'exe flag', and relaunches the program at the necessary point
(this avoids redoing everything already done for 'exe' <4)
calls one of polenumerics.pl, finishpolenumerics.pl ./batch*l*h* or results.pl
perlsrc/finishpolenumerics.pl:
checks whether there are any poles of this type, and if so completes the numerical calculation by
calling the various scripts point_subfile.pl
justnumerics.pl:
if fortran files f*.f have been produced, then by changing the point name and masses/invariants in the parameter
file and typing './justnumerics.pl [-d workingdir -p paramfile]' you can produce numerical results
for many different points in phase space
(it skips the mathematica subtraction+epsilon expansion step which can be done once and for all,
as the kinematic variables at this stage are still symbolic).
Usage is identical to subexp.pl
Additional code:
perlsrc/getinfo.pm:
contains subroutines used by various scripts to retrieve pieces of information
stored in intermediate/output files.
perlsrc/launchjob.pm:
whenever a process is submitted to the specified batch system, syntax in launchjob::submit is used
If a system different from PBS is used, syntax must be added to 'submituserdefined'.
perlsrc/mathlaunch.pl:
contains the syntax used to launch Mathematica scripts. NB SecDec requires Mathematica v6 or above,
so if the command 'math' launches an earlier version by default on your machine, this syntax needs to
be changed.
----------------------------------------------------------------------------------------------------------------
Additional information:
Parameters used by routines in the Cuba library are explained in more detail
in Comp.Phys.Comm. 168 (2005) 78 [hep-ph/0404043] by T.Hahn,
resp. in Cuba-2.1/cuba.pdf.

File Metadata

Mime Type
text/plain
Expires
Wed, May 14, 10:17 AM (1 d, 16 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
4928998
Default Alt Text
README (11 KB)

Event Timeline