SSmm

Numerical implementation of the double-soft integral for massive-massive emitters at arbitrary angle

Installation

A recent version of the package could be obtained from the git repo and compiled on any machine with a C compiler and GSL library available

$ git clone https://github.com/apik/SSmm.git
$ cd SSmm
$ make

After compilation, the library file libSSmm.a and two example programs pointQQ and pintGG are produced

Benchmark points

Results from the table with benchmark points for the quark and gluon case could be obtained with

$ ./pointQQ <NI> <NJ> <NTH>
$ ./pointGG <NI> <NJ> <NTH>

where input parameters are defined through be_I = NI/25, be_J =NJ/25, cos(Theta) = Pi*NTH/25

Example application

As the input parameters, we use three numbers bei,bej,cTh, corresponding to two velocities and a cos of the relative angle. For a specific epsilon order EORD, pole parts are calculated for quarks(EORD=-2,-1) and gluons(EORD=-3,-2,-1) through the call

double poleQQ = SSmmQQgpl(EORD, bei, bej, cTh); /* quarks */
double poleGG = SSmmGGgpl(EORD, bei, bej, cTh); /* gluons */

The finite part is made from two pieces: the analytical result available from

double resQQfinGPL = SSmmQQgpl(0, bei, bej, cTh); /* quarks */
double resGGfinGPL = SSmmGGgpl(0, bei, bej, cTh); /* gluons */

and a finite reminder calculated by numerical integration

/* Verbosity level, possible values: SSMM_VERB1, SSMM_VERB2 */
SSmmVerbosity verb = SSMM_QUIET; 
double resQQfinINT, errQQfinINT, resGGfinINT, errGGfinINT;
fintQQ(bei, bej, cTh, &resQQint, &errQQint, verb);
fintGG(bei, bej, cTh, &resGGint, &errGGint, verb);

Full finite part result is a combination of GPL parts resQQfinGPL and resGGfinGPL with results of integration resQQfinINT and resGGfinINT

double resQQ = resQQfinGPL + resQQfinINT;
double resGG = resGGfinGPL + resGGfinINT;

A minimal working example is provided in the file mwe.c

#include <stdio.h>
/* Main library header */
#include "SSmm.h"

int main()
{
  /* Input parameters */
  double bei = 0.1;
  double bej = 0.2;
  double cTh = 0.3;

  /* Pole parts VALUE returned */

  /* ep^-2 part QQ */
  double QQepM2   =  SSmmQQgpl(-2, bei, bej, cTh);
  /* ep^-1 part QQ */
  double QQepM1   =  SSmmQQgpl(-1, bei, bej, cTh);
  /* finite GPL part QQ */
  double QQep0gpl =  SSmmQQgpl(0, bei, bej, cTh);

  /* ep^-3 part GG */
  double GGepM3   =  SSmmGGgpl(-3, bei, bej, cTh);
  /* ep^-2 part GG */
  double GGepM2   =  SSmmGGgpl(-2, bei, bej, cTh);
  /* ep^-1 part GG */
  double GGepM1   =  SSmmGGgpl(-1, bei, bej, cTh);
  /* finite GPL part GG */
  double GGep0gpl = SSmmGGgpl(0, bei, bej, cTh);

  /* Finite parts (VALUE, ERROR) returned */
  double resQQ, errQQ;
  fintQQ(bei, bej, cTh, &resQQ, &errQQ,
         SSMM_QUIET /* verbosity level: SSMM_VERB{1,2,3}*/
         );

  double resGG, errGG;
  fintGG(bei, bej, cTh, &resGG, &errGG,
         SSMM_QUIET /* verbosity level: SSMM_VERB{1,2,3}*/
         );

  /* combined finite parts */

  printf("Gluons\n");
  printf("\tGG(ep^-3) % .12f\n", GGepM3);
  printf("\tGG(ep^-2) % .12f\n", GGepM2);
  printf("\tGG(ep^-1) % .12f\n", GGepM1);
  printf("\tGG(ep^0)  % .12f +/- %.12f\n", resGG + GGep0gpl, errGG);
  printf("\n");

  printf("Quarks\n");
  printf("\tQQ(ep^-2) % .12f\n", QQepM2);
  printf("\tQQ(ep^-1) % .12f\n", QQepM1);
  printf("\tQQ(ep^0)  % .12f +/- %.12f\n", resQQ + QQep0gpl, errQQ);
  printf("\n");

  return 0;
}

In the project directory, compile with the following command(provide include and library path for GSL if needed) and run

$ gcc -O2 mwe.c -L. -lSSmm -lgsl -lm -o mwe
$ ./mwe

The following output is produced for example input point be_I=0.1, be_J=0.2, cos(theta)=0.3:

Gluons
        GG(ep^-3)  0.012995576343
        GG(ep^-2)  0.006863386751
        GG(ep^-1)  0.038410643276
        GG(ep^0)   0.077401593773 +/- 0.000002456437

Quarks
        QQ(ep^-2)  0.004331858781
        QQ(ep^-1) -0.000156994797
        QQ(ep^0)  -0.000124779027 +/- 0.000000287302