Program package for calculating matrix elements of two-cluster structures in nuclei

Computer Physics Communications 28 (1982) 153—182 North-Holland Publishing Company

153

PROGRAM PACKAGE FOR CALCULATING MATRIX ELEMENTS OF TWO-CLUSTER STRUCTURES IN NUCLEI R. KRIVEC and M.V. MIHAILOVIC J. Stefan Institute, E. Kardelf University, FOB 53, 61111 Ljubljana, Yugoslavia and Kernforschungszentrum Karlsruhe, Institut für Angewandte Kernphysik II, FOB 3640, 7500 Karlsruhe, Fed. Rep. Germany Received 29 April 1982

PROGRAM SUMMARY Title of program: DFIDTH

Keywords: integrals over angles, partial-wave expansion, word addressable files

Catalogue number: AAOG Program obtainable from: CPC Program Library, Queen’s University of Belfast, N. Ireland (see application form in this issue) Computer: CDC Cyber 172; Installation: RRC Ljubljana Operating system: NOS/BE 1.3 Programming language used: ANSI FORTRAN (exceptions)

Nature of physical problem Matrix elements of operators between Slater determinants of two-cluster structures must be expanded into partial waves for the purpose of angular momentum projection. The expansion coefficients contain integrals over the spherical angles 8 and q’. Method of solution All integrals needed (see program PRO2C) are calculated using analytical formulae and stored in a file with the CDC Word Addressable organization. This file is used by the program PRO2C.

High speed storage required: 40300 words (octal) for the test version No. of bits in a word: 60

Restrictions on the complexity of the problem No restrictions of physical nature. Typical running time

Peripherals used: card reader, line printer, I permanent disk file

1.1 s for the test run.

No. of cards in combined program and test deck: 269

Unusual features of the program A disk file with the CDC Word Addressable organization is

Card punching code: 29

used (with the Record Manager routines).

PROGRAM SUMMARY Title of program: STOKER

Operating system: NOS/BE 1.3

Catalogue number: AAOH

Programming language used: ANSI FORTRAN (exceptions)

Program obtainable from: CPC Program Library, Queen’s University of Belfast, N. Ireland (see application form in this issue)

High speed storage required: 120400 words (octal) for the test version

Computer: CDC Cyber 172; Installation: RRC Ljubljana

No. of bits in a word: 60

OOlO-4655/82/0000—0000/$02.75 © 1982 North-Holland

R. Krivec, M. V. Mihailovic~/ Matrix elements of two - cluster structures

154

Peripherals used: card reader, line printer, I permanent disk file No. of cards in combined program and test deck: 1000 Card punching code: 29 Keywords: cluster model, symbolic algebra, symbolic-numerical information conversion, word addressable files Nature ofphysical problem In the cluster model, the matrix elements of operators between Slater determinants of cluster structures must be evaluated by symbolic algebra programs because of their length and number, They are the building blocks for the matrix elements between nuclear eigenfunctions of total angular momentum and parity. Therefore the symbolic expressions have to be converted to an equivalent set of numerical data and the latter stored for easy access (by program PRO2C). Method of solution A special set of subprograms reads and interprets the symbolic expressions. The numerical information so obtained is written

into a file with the CDC Word Addressable organization in a space-saving form. Parts of information belonging to given operators and bra—ket clustering pairs can be accessed using pointers stored in the beginning of the file. Program STOKER can update the file many times. Restrictions on the complexity of the problem Restrictions are imposed by the symbolic expressions interpreting subprogram package. The expressions can have at most 99 terms (of the form exponential function times a polynomial in several variables) and the powers of variables in polynomials can be one-digit only. A polynomial can be at most 1000 characters long (80 characters per card). These restrictions can be removed. Typical running time 1.0 s for the test run. Unusual features of the program A disk file with the CDC Word Addressable organization is used (with the Record Manager routines).

PROGRAM SUMMARY Title of program: PRO2C

Program obtainable from: CPC Program Library, Queen’s University of Belfast, N. Ireland (see application form in this issue)

matrix elements of the Hamiltonian and the identity between functions obtained from Slater determinants of cluster structures by the angular momentum and parity projection. The purpose of program PRO2C is to calculate the necessary matrix elements. Method of solution

Computer: CDC Cyber 172; Installation: RRC Ljubljana

Projection of angular momentum and parity employed [1] is an algebraic one without resort to numerical integration. Matrix

Operating system: NOS/BE 1.3

elements between projected functions are expressed in terms of those between unprojected ones (Slater determinants). The

Programming language used: ANSI FORTRAN (exceptions)

latter are first expanded into partial waves. Program PRO2C then uses the two files with the Word Addressable organization

Catalogue number: AAOI

High speed storage required: 76 100 words (octal) for the test version No. of bits in a word: 60 Peripherals used: card reader, line printer, 2 permanent disk files (created by programs DFIDTH and STOKER) No. of cards in combined program and test deck: 2246 Card punching code: 29 Keywords: cluster model, interplay of different cluster structures, angular momentum projection, symbolic algebra, word addressable files Nature of physical problem The dynamics of a nucleus with cluster structure or with an interplay of different cluster structures lie in the corresponding Hill—Wheeler equation [I]. The kernels of this equation are

constructed by the programs DFIDTH and STOKER, respectively. The program is optimized with respect to time consumplion. Restrictions on the complexity of the problem The present version of PRO2C allows for at most one Ip single particle state in any given cluster Structure, and for at most two nucleons in the unfilled shells. These restrictions affect a comparatively small part of subprograms and can be removed (see below). Typical running time 2.7 s for the test run. Unusual features of the program Two disk files with the CDC Word Addressable organization are used (with the Record Manager routines). Reference [I] M.V. Mihailovu~and M. Poljiak, NucI. Phys. A3 11(1978) 377.

R. Krivec, M. V. Mihailovic~/ Matrix elements of two - cluster structures

155

LONG WRITE-UP Contents I. Introduction 1.1. Formalism 1.2. Calculation of matrix elements 2. Structure of the program package 2.1. Relations between the programs 2.2. General remarks on programming 2.2.1. Machine-dependent features 2.2.2. Dimensioning the arrays 2.2.3. Zero presetting 3. Program DFIDTH 3.1. General description 3.2. Calling sequences and subprogram description 3.3. COMMON and other dimensions 3.4. Description of input 3.5. Description of output 4. Program STOKER 4.1. General description 4.2. Calling sequences and subprogram description 4.3. Description of input

.

.

155 155 156 158 158 159 159 159 160 160 160 160 161 161 161 161 161 162 165

4.4. Program flow diagram

166

4.5. Description of output

166

4.5.1. Printed output 4.5.2. The file KERSTO 4.6. Limitations of the program 4.7. Comments on symbolic evaluation of kernels . . 5. Program PRO2C 5.1. General description 5.2. Calling sequences and description of subprograms 5.3. COMMON statements 5.4. Description of input 5.4.1. Input from unit LFNSTA 5.4.2. Input from unit LFNEXP 5.4.3. Input from unit LFNDAT 5.5. Program flow diagram 5.6. Description of output 5.6.1. Printed output (unit LFNPR) 5.6.2. Results in a file (unit LFNPUN) 5.7. Limitations of the program 6. Test run descriptions

166 166 167 168 169 169 169 172 173 173 174 175 175 175 175 176 176 177

I. Introduction A package of three programs for calculating matrix elements of the identity, kinetic energy and potential energy operators between antisymmetrized wave functions of two-cluster structures in light nuclei is presented. A wave function of the generator coordinate type is used. This function may also contain the superposition of wave functions corresponding to different cluster structures. The functions are projected onto the subspace of eigenfunctions of the total angular momentum and parity operators. The package employs the expressions for matrix elements between functions devoid of these symmetries, evaluated by a symbolic algebra program. 1.1. Formalism A brief survey will be given only. The reader is referred to ref. [1] for more details. We start from single-particle wave functions p,( x, SA) and q~,(xi, S8) in the Cartesian representation describing nucleons in harmonic oscillator states centred at the points SR and SB, respectively. The exponential part of the spatial wave function is (1.1)

exp[~~(r~{~})2J,

/1 is spin I, v: where

the oscillator parameter. We form Slater determinants and couple them to functions with good

4)eaijp(x,

5) =[c~(cp~(x1,SA)”

tP.4(XA,

SA)~A+l( xA÷l, SB)•.•

~A÷B(xA+B,

SB))] ~

(1.2)

where ~ is the antisymmetrization operator, x~are the nucleon coordinates (spatial, spin and isospin),

R. Krivec, M. V. Mihailovi,~/ Matrix elements of two - cluster structures

156

5B is the generator coordinate. The index c denotes a particular cluster x = (x1,. X,~+B) and S = structure, ~ stands for the labels of the spatial parts of the valence nucleon states, and J~stands for the intermediate spins obtained by coupling the nucleon spins to the total spin. The closed shells should have no holes and the oscillator parameters of both wells should be equal in order to avoid spurious centre of mass motion [1]. Applying the projection operators for the total angular momentum J, M and parity we obtain our basis functions: . .,

—

~-

,~JMir

f

c’\_DJ

~‘1—

~f~ca!,/~K~.X,

=

DITA

i~

MK

2J± 1 JdQ6O~K(Q)*D(Q)~[ ~

S)

+

(— l)~~jj~(x, —S )~,

(1.3)

where s is the sum of the single particle angular momenta measured about the corresponding centres. The Hamiltonian is

H-~ where

T~mis

A+B

~

A+B

i=1

i.’zj=2

~

r’~,,

(1.4)

the centre of mass energy. We assume that the various kinds of the two-body interaction V,

1 can be written as a sum of Gaussian terms with different ranges

Pk

and strengths

I/Ok:

(1.5)

~vokexP[_(—)}.

The Coulomb interaction can also be written in this form. The equation of motion is (1.6) where the trial wave function is ~JM~(x)

J

~

=

cal, JvK

dSf~K(S)~J~PK(x, 5).

0

As we take all the projections K of the total angular momentum and all spins into account, we can put S parallel to a fixed direction (z axis) [11. Eq. (1.6) reduces to the Hill—Wheeler equation

o

=

JdS’f~,~x(S’)(c5~x(S)I(H

~

-

EI)I~. ~‘~~(~‘)).

c’a’l’,l’v’K’ 0

To solve it, we transform it into an algebraic system of equations by taking a finite sum over discrete values of S’ in place of the integral. 1.2. Calculation of matrix elements

In order to calculate the value of the matrix element j~JM,r ( \ ‘t’,~,,JJpK\

\ /

~ (~‘ l’f’c’a’I’ 1’~’K’’.

,

where 0 is an operator from (1.4), we express it in terms of the matrix elements between functions (1.2), using (P~x)tP~K,= ~KK” and 6 p(Q)~ca’jj~’(X, R(f~)S), (1.8) D(Q)~~ajj~(X, S) = a,’ ~ ~‘a(Q)

R. Krivec, M. V. Mihailovh~/ Matrix elements of two - cluster strUctures

157

where ~a(~) can be expressed by ‘v-functions [1]. (For example, if there is one ip state in the function (1.2), ~ is equal to the rotation matrix element for the Cartesian vectors.) We obtain for (1.7): 2J

l

a~’v” 81T

x <~aj ,~(S)1013[

R( Q)s’) +

4’ca’,~ ~

(—

1Y’4~c~a~~i’— R( ~2)s’)]).

(1.9)

The matrix elements on the r.h.s. of eq. (1.9) have the form =

~

~/Ts’) exp(a~S2 + b;~sf2+ c;~’~s.S’)~

(1.10)

where r is the range index, and P is a polynomial of N~terms: ~oc;r(~Ts,

as’)

~

(1.11) For the sake of simplicity we have omitted quantum numbers from the l.h.s. of eq. (1.10), and in and K~gr.Besides, the functional dependence of the powers, L = L( p, t, a, a”), etc., is suppressed. We expand the expression (1.10) in terms of products of real spherical harmonics defined through the ordinary harmonics, 1 kq’~

2Re

~

k+1~q~2k+l 1~q~k

Yk.q—k_l(S),

2ImY~(S),

whose orthogonality relation is kq( ‘~, q~)Rkq~( 1~, P) f2’~dqfsin i~dt~R

8kkôqq’(l +

and which have the rotational property (S parallel to the z axis)

(R(f~)~)=~I2h1~ Re’~_k_IO(Q),

Rk

21T

q

_Im6D~(Q),

k+1~
1~q~k

which reduces to Rkq(~)=

V/2k±

8q,k+1

An exponential function is expanded as follows 2X+1

exp(cS.S’) = 4~-~ i~(cSS’) ~ x=o

(1

+

where i~(x)is the modified spherical Bessel function of the first kind (see ref. [2J, 10.2.2). The final expression for the matrix element (1.7) is L+M+N

2k’+l ~

q~1

~

~

L+M’+N

—

s’)

R. Krivec, M. V. Mihailovh~/ Matrix elements of two - cluster structures

158 ______

x ~V2k+

I

k

~

Afl,,,,

2X+1

~

~

(1 +~~+1)~(L, M, N; k, k+ 1; A, ~)~L’,

M’, N’; k’, q’, A,

~t)

~‘1

~ exp(a~~~~ + ~

(1.12)

The order of summations takes into account the mutual dependence of the indices. We introduced =

2J+ 1 fdf~6D~Kl(~)*~a(

2 Re

~

Dq_k~_~,0(Q),

Q)

k’ + 1 ~ q’ ~ 2k’ + 1

(1.13) SLSMSY

~(L,M,N;k,q;A,IL)=JdS~~~Rkq(S)RA1l(S)

l~q’~k’

(1.14)

and the relations specifying the ranges of summation indices are

k’ ~J

+

I’

+ s’,

parity of k’:

(—

j)~S;

k~
parityofk:(—l)’~’;

L’+M’+N’+k’),

Amax=min{L+M+N+k;

(1.15)

Xmin=max{miii~(L, M, N)—kj,minhi~(L’,M’, N’)—k’I~, parity ofA: (—1)

L±M+N±k =

(—1)

L±M’+N’±k

where e(L, M, N) runs over angular momenta in the expansion of S~S~’SY into spherical harmonics.

2. Structure of the program package 2.1. Relations between the programs The package consists of three programs named PRO2C, STOKER and DFIDTH, respectively. Program PRO2C calculates the values of the matrix elements (1.9) between angular momentum and parity projected states of various clusterings. Part of its input is provided by the outputs of the programs STOKER and DFIDTH in the following way. (i) A file is written by the program STOKER containing the numerical information on the matrix elements (1.10) (sometimes called “kernel” in what follows) between unprojected functions. This information includes the coefficients K~,rand powers L, M, N, L’, M’ and N’ of the polynomial terms in eq. (1.1 1). (Information on the coefficients a,~1,b,~.,and c~’is input separately directly to the program PRO2C.) The explicit expressions for the kernels (1.10) are assumed to have been evaluated by a symbolic algebra program such as SCHOONSCHIP on CDC or REDUCE on IBM machines (see section 4.7), and provide the input to the program STOKER. The file is referred to with the file name KERSTO. (ii) Another file, named INTSTO, is written by the program DFIDTH, and contains integrals over the spherical angles i~and q which are needed to assemble the integrals (1.14). Moreover the program STOKER can update the file KERSTO on subsequent runs. It can overwrite a

R. Krivec, M. V. Mihailovi6

/ Matrix elements of two cluster structures -

159

part of information corresponding to a particular operator and clustering pair (c, c’) with a new version, which normally corresponds to changing the parameters such as $ or the potential energy parameters. It can also add new such blocks to the file. The way the package works is depicted in fig. I, where the input and output files for the programs are also indicated. 2.2. General remarks on programming 2.2.1. Machine-dependent features The programs employ the CDC Record Manager routines FILEWA, OPENM, GET, PUT and CLOSEM to establish the Word Addressable (WA) file organization in the files KERSTO and INTSTO and to perform input/output (I/O) operations referring to these two files. (The essential feature of the WA organization is that the file is treated as a sequence of words where any word or word group can be accessed randomly for reading or writing.) The files consist of blocks of information of unequal lengths that are accessed randomly but read or written sequentially. The most straightforward way to implement the present programs on a different computer is to write substitutes for the I/O routines GET and PUT. The reader is also referred to ref. [3J. Other machine-dependent features are the PROGRAM cards and the use of the CDC EOF function in the subroutine NEXTR4 (see section 4.2, description of subroutine GPOL). 2.2.2. Dimensioning the arrays The dimensions that can change are passed to the subprograms through the argument lists in the form of INTEGER variables. These variables are given values in DATA statements in the main programs. The dimension declarations in the main programs are repeated as comments with variables in place of constants to facilitate changes. These involve the DATA and DIMENSION statements in the main programs. An exception to this are a few COMMON declarations and a DIMENSION declaration in the function DRLA (section 5.2) connected with the COMMON. Such dimensions are explained in the program texts.

SYMBOLIC EXPRESSIONS FOR KERNELS

PARAMETERS

f~FIo1I4

]

[ I

PARAMETERS PRINTED

SINKER]

FILE KERSTO MODIFICATIONS INFORMATION PRINTED

Fig. I. Relations between the programs in the package. Rough descriptions of the contents of the input and output files are given. The files named INTSTO and KERSTO have the word addressable organization.

R. Krivec, M. V. Mihailovi~/ Matrix elements of two - cluster structures

160

More important subroutines have all arguments explained which also helps understand the meaning of various dimensions. 2.2.3. Zero presetting No variable or array is assumed to be preset to zero by the machine at load time. Presetting should be avoided since it obscures the distinction between the defined and undefined quantities.

3. Program DFIDTH 3.1. General description Program DFIDTH calculates values of the following integrals: D~(L,M, n)

=

2~e1~~R~(cos q~)L(sinP)Md~

(3.1)

iMj

(3.2)

D~(k,q;A,p.;~ where Pp” are the associated Legendre polynomials [2]. They are calculated using the formulae: D~(L,M, n)

=

~

L+M+I

(~ l)m6L+M+fl

2I±2fl,(~)(M),

1=0 ,n’=O 1k—q1 1A—~i1

q; A,

r!(k

—

~ L,

N)

r)!(k

(2k — q

________

2

‘

=

— —

1

+

(~ 1)k_~+x_M+N]

2r)!(2A — 2v)! 2r)!v!(A — v)!(A

—

j.i

—

2

r=0

~

(—

iy~

2v)!

k—q—2r+A—,u—2v+N+ 1 2

where B(p,q)=F(p)F(q)/T’(p+q), and ~ Triangular selection rules are observed when the integrals are evaluated, and the integrals are stored into arrays with single indices in a condensed form. The number of values of the integrals calculated depends on the input parameters (section 3.4). The values are then written into the file INTSTO. They can be retrieved from the file by the routine DRLA (section 5.2). 3.2. Calling sequences and subprogram description Calling sequences are shown in fig. 2. The subprograms are all FUNCTION subprograms, and they

XFAC__~~~~_OFIOTH_~~~~~~~~~1__DIM

DIN

SlIM

Fig. 2. Calling sequences of the program DFIDTH.

R. Krivec, M. V. Mihailovi~/ Matrix elements of two - cluster structures

161

return the values as follows: XFAC(n)=n!,

BIN(n,m)=(t~i1),

XDFAC(n) = n!!,

DFI(L, M, n) = D,~(L,M, n) (see eq. (3.1)),

DTH(k,q,X,~i,LM,N)=D,,(k,q;A,.t;LM,N)

(seeeq.(3.2)),

~

3.3. COMMON and other dimensions

There are COMMON statements in DFIDTH, DTH, XITH and BIN, defining a blank COMMON area containing factorials and double factorials. These and another two dimensions are explained in the comment in DFIDTH. The present dimensions allow for (see eq. (1.15)) J + I’ + s’ ~ 5, and for fourth order polynomials in the expressions for kernels (1.10). 3.4. Description of input The single input card formatted (514) defines five parameters which are as follows (in the order they are read): JMX

=

MICX

max(max(L), max{M)) + 1, =

max(q + ,.t)

LCX=max(k)+ 1,

+

1

=

max(k

+

A) + 1

LAX=max{A)+ 1,

=

LCX

+

LAX

—

1,

LMX=max{L+M)+ 1,

where the notation and meaning of symbols are as in eq. (1. 15). The present dimensions (compare section 3.3) allow for JMX =5, MICX = 19, LCX = 10, LAX = 10, LMX =5.

3.5. Description of output A file named INTSTO contains the values of the integrals in the word addressable organization. All the DR, values are written starting in position 1. The .0,, values are written in LMX (LMX + 1 )/2 blocks, each block uniquely determined by the values of LM and N (eq. (3.2)), where LM = L + M, in the above notation (section 3.4). The printed output merely displays the actual array sizes and the file space used. No diagnostics are provided.

4. Program STOKER 4.1. General description This is a program for creating and modifying the file KERSTO (section 2.1). Its input consists of card decks (or 80 column card images in a file) produced by a symbolic algebra evaluation program containing expressions for the kernels (1.10) in a special form to be described below. Since the polynomial coefficients K~,r(eq. (1.11)) must appear as numbers, separate expressions must be supplied for each term corresponding to a particular range in case of a potential energy operator. Twice as many expressions must be

R. Krivec, M. V. Mihailovi~/ Matrix elements of two - cluster structures

162

supplied if the kernel has both real and imaginary parts. Such groups of expressions, each group corresponding to a fixed set of quantum numbers, are preceded by identifying cards, and assembled into blocks preceded by higher-level identifying cards. Each block corresponds to a given pair of the cluster structures in the bra and ket and to a given operator. The input is read sequentially and from each expression the information is extracted. This purely numerical information is written in a condensed form into the file KERSTO. Each input block transforms into a block in the file. The program is aware of the positions of the blocks in the file by maintaining a pointer array in the beginning of the file. Whenever a new block is encountered on input, the program checks, using the pointer array, whether an old version exists already in the file, and decides on the action to be taken (overwriting or adding). The pointers are also employed by the program PRO2C subroutine GETKER to find and read the block needed. If two or more clustering pairs have the same kernels for some operator, or differing at most by sign and/or complex conjugation, the corresponding pointers can be caused by the user to become equal. The missing sign, etc., is supplied separately to the program PRO2C. Similarly, the kernels of any clustering pair/operator need be kept in the file only for those sets of quantum numbers for which they differ at most by sign and/or complex conjugation. At the same time, the kernels for only those values of the labels a, a” need be kept from which all others can be obtained by permutations of the powers in polynomial terms (1.11). Such symmetries are taken into account by the program PRO2C, and will be discussed in section 5.1. 4.2. Calling sequences and subprogram description The calling sequences of the program STOKER are shown in fig. 3. The subprogram description in this section serves to explain the form of the symbolic expressions acceptable. Further questions pertaining to this are dealt with in section 4.7. GPOL — this subroutine is the main one in the package consisting of the subprograms GPOL, NEXTR4, NCHP4, ERRPOL, TSUME4, TERMX4, COEF4, SETVAR and BLKDAT. This independent package interprets symbolic expressions for the kernels and extracts numerical information from them. GPOL reads (by calling NEXTR4) cards in A format, 80 characters per card, but treats the input as a single string extending over many cards. GPOL starts interpreting when the equals sign is encountered, and stops when the character combination “+ E” is encountered. (Any subsequent READ on the input unit would refer the card following the card containing the letter “E”.) Blanks are immaterial, and the expression can

ALI5N:~TjTiTTTT1\~TTTiT~ ITEXIBI

[

NEXTR4

ERRPNL

~~

F—~

GPOL

BIKOAT

NCHP4 .~~j

1TSUME4

CNEF4

IVAI

ENCOON

I

~...—~_T[RMX4

Fig. 3. Calling sequences of the program STOKER. The middle 9 subprograms form the GPOL package. SETVAR is not used in the program STOKER.

R. Krivec, M. V. Mihailovi~/ Matrix elements of two - cluster structures

163

continue on another card at any character. Recognizable input is composed of at least one term of the form Nm

*

(polynomial),

(4.1)

the terms being separated by the character” + m is a one or two digit number (the present version allows for at most N99) and the symbol Nm in our case labels a particular exponential function in eq. (1.10). N02 is equivalent to N2. “Polynomial” must be in terms of the variables X, Y, Z, XP, YP and ZP. (This default setting can be changed by calling SETVAR prior to calling GPOL, and the number of variables can be increased to 10. SETVAR is not used in the present program, but is included in the package.) The variables can have one-digit powers. The “polynomial” must have at least one term, the terms being separated or preceded by the characters” +“ or” and having either a REAL or INTEGER numerical coefficient or none at all. Exponential notation is not allowed. An example of a valid expression is (each line means one card) “.

— “,

=N02*(l)+Nl*(—0.273*Z* *9— 2*X*XP* *2*Zp* *3—0.1)+Nl

(4.2)

2*(X — 2.93*X*X

P*Z*ZP**3)+E..., where the dots stand for any number of any characters. GPOL returns the following information: NPOL — number of polynomials in the expression. NFC — array dimensioned NFC (MAXPOL), where MAXPOL is the maximal number of polynomials possible, containing the labels m, eq. (4.1). Labels are arranged in the sequence they appear in the input. NT — array dimensioned NT (MAXPOL), containing the numbers of terms in each polynomial. C — array dimensioned C(ND, MAXPOL), where ND is the maximal number of terms in any polynomial, containing the numerical coefficients of polynomial terms, as REAL numbers. IEXP — array dimensioned IEXP (10, ND, MAXPOL), containing the powers of variables in the polynomial terms, as INTEGER numbers. In the case (4.2), NPOL NFC NT C

IEXP

=3 = = =

=

2 1 1.0

0000000000

1 3 —0.273 —2.0 —0.1 0090000000 1002030000 00000 00000

12 2 1.0 —2.93

(4.3)

1000000000 1011030000

Other subprograms from the GPOL package need not concern the user, except that he must call the subroutine BLKDAT (no argume~ts)to initialize the labelled COMMON internal to the package. (This COMMON defines characters recognized in the input and can be modified by the user if necessary.) If an error occurs, NPOL is set to zero and a message is issued by the subroutine ERRPOL. DROPTE — this subroutine drops specified terms in the arrays output by GPOL. This is required since some symbolic algebra programs cannot output a term like N12*(2).

R. Krivec, M. V. Mihailovic / Matrix elements of two - cluster structures

164

This would always appear as 2 * N12. To force the presence of brackets required by GPOL, one must then add terms which are known not to appear in the true kernels. In the above example (4.2) one would add for example Xi’ *9*(N02+Nl +Nl2), to obtain ...N02*(1+X**9)+Nl*...,etc. Dropping the terms of the form Z* *9 in the case (4.2) would modify the arrays (4.3) as follows: NPOL NFC NT C IEXP

=3 = = =

=

2 1 1.0 0000000000

1 2 —0.1 —2.0 0000000000 1002030000

12 2 1.0 —2.93 1000000000 1011030000

No action is taken if the specified terms do not appear in the expression. ALIGNC — This subroutine compares the GPOL output arrays for two expressions. Without changing the expressions, it modifies the arrays so that new single arrays NFC, NT and IEXP result, and two new arrays C. If some of the terms in the two expressions are equal, this results in a considerable saving in space when the arrays are written into the file KERSTO. Such “alignment” is done, by successive calls to ALIGNC, for all expressions of a given kernel corresponding to different ranges and complex parts, so that NFC, NT and IEXP are stored only once for all of them. This subroutine is called after DROPTE. As it cannot handle polynomials with no terms, care must be taken that each polynomial in the input contains at least one term beside that, if any, to be dropped. See also section 4.7. The working of ALIGNC will be clear from the following example: Input: NPOL1 NFC1 NT1

=2 = =

C1

=

IEXP1

=

5

I 1.0 1000000000

3 2 2.0 3.0 0100000000 0010000000

NPOL2 NFC2 NT2 C2

IEXP2

=2 = = =

=

Output: information is in the following arrays: NPOL1 NFC1 NT1 IEXP1

=3 = = =

5 1 1000000000

3 3 0100000000 0010000000 02000 00000

2000000000

1 1 4.0

2000000000

3 3 5.0 6.0 7.0 0010000000 02000 00000 0100000000

R. Krivec, M. V. Mihailovi.~/ Matrix elements of two - cluster structures

C1

165

2.0 0.0 (4.4) 3.0 0.0 C2 = 0.0 7.0 4.0 5.0 6.0 The zeros in ~are not supplied by ALIGNC; STOKER predefines them before GPOL is called (since program PRO2C has to interpret them as zero coefficients). =

1.0

NEXTBL finds the beginning word address of the block in the file KERSTO following the block currently dealt with in the program to avoid its inadvertent destruction. —

ENCODN converts a sequence of digits into a single number, treating them as digits in a system with a prescribed base. Here the digits are the powers from the array IEXP, and the base is the parameter JMX of the program DFIDTH. This is to save space in the file. —

IVAL

—

RVAL

-

sets an INTEGER array to a given value. as IVAL, for REAL arrays.

4.3. Description of input The identifying cards (see section 4.1) are read by the program STOKER itself, and the expressions subsequently by calls to GPOL. The input is assembled as follows: Card 1 Card 2 Block 1 Block 2 Block n Last card where the items are: Card 1 Card 2

Block:

(L 1) LNEW (“T” if this is the file creation run, “F” if a file modification run). “T” causes the file to be treated as blank, i.e. any old information is ignored. (2014) JMX, NVAR, (IEDROP (IA), IA = 1, NVAR). For JMX, see the description of subroutine ENCODN (section 4.2). NVAR is the number of variables in polynomials (6 for two-cluster structures, but see also section 4.6). IEDROP are the powers of the terms to be dropped. In case X * * 9 is to be dropped, IEDROP = (9, 0, 0,...). is the information pertaining to a definite clustering pair c, c’) and a definite operator. Its structure is either .(

Identifying card Group 1 Group 2 Gioup NKERN or Identifying card

(4.5) (4.6)

R. Krivec, M. V. Mihailovi~/ Matrix elements of two - cluster structures

166

Identifying card (614) ICLUS, lOPER, ICLSYM, NKERN, NRAN, LASTB. ICLUS is the sequential number of the pair (c, c’) and lOPER of the operator. They serve as indices of the pointer array. ICLSYM is zero in the case (4.5). In the case (4.6) it is nonzero and causes the (ICLUS, lOPER) pointer to become equal to the (ICLSYM, lOPER) pointer (see section 4.1). NKERN is the number of sets of quantum numbers the kernels will be read in for. NRAN is the number of ranges of the operator (1 for the identity and kinetic energy). LASTB is the number of free words in the file KERSTO to be left after the present block if another one should be added. It is ignored if the present block is replacing an older version. LASTB assures that a new version of a block will not extend over the beginning of the block following. (If it does so, the program stops with a warning.) Different lengths of versions can originate because some polynomial coefficients can vanish for a particular choice of parameters. Group: is structured as follows: Identifying card Expression I Expression 2 Expression (1R12

—

IRII

+

l)*NRAN

where Identifying card (514) IKERN, KO, KPO, IRIl, 1R12. IKERN is a unique designator of the group, without loss of generality confined to between 1 and NKERN. For its role in the program PRO2C, see section 5.1. KO and KPO stand for the labels a, a” (eq. (1.9)). See also section 4.6. IRII and IRI2 describe the real/imaginary property of the kernel: if (1,1), it is real, if (2,2), imaginary, and if (1,2), it has both complex parts. Expression: is a symbolic expression for the kernel, output by the symbolic algebra program, in the form described in section 4.2. Expressions must be ordered as follows: depending on IRI1 and 1R12, the single or both complex parts (real first) for the first range, the same for the second range, etc. Last card (14) must contain a zero to stop the program. Any number of blocks can therefore be included in the input. 4.4. Program flow diagram The program STOKER flow diagram is given in fig. 4. 4.5. Description of output 4.5.1. Printed output

If the file KERSTO is being modified (LNEW = .FALSE.), the old block pointers are printed in the beginning. Subsequently, the statistics appear for each block processed. They consist of the information from the identifier cards and the updated block pointers. The action taken (overwriting or adding) is specified, and the current last word + 1 of the complete information is printed together with the number of words to be left free if another block is added. Warnings and error messages appear as indicated in fig. 4. 4.5.2. The file KERSTO

The file is treated as a one-dimensional array of an arbitrary length. Starting from the first word, the

(

( ‘—

R. Krivec, M. V. Mihailovi~/ Matrix elements of two - cluster structures

167

pointer array is written, followed by LAST1 and LASTX. LAST1 is the last word + 1 of all information currently in the file, and is determined by the program. LASTX is the LASTB parameter (see section 4.3) read in when the currently last block was added to the file for the first time. The first block starts immediately after LASTX, other blocks following with the corresponding gaps in between (see input block description, section 4.3). The first two words in a block are occupied by NKERN and NRAN. Then the parts of information corresponding to the input groups are written one after another, each represented by the sequence IKERN, KO, KPO, IRIl, IRI2, JMX, NPOL, NC, NCC, NFC, NT, IEZ and CX. IEZ contains numbers obtained from the powers by the subroutine ENCODN, for all existing terms in all polynomials, while CX contains the corresponding coefficients, for all expressions in the group. In the example (4.4) (two expressions) the length of IEZ would be 5, and of CX, 10 words. These two lengths are given by NC and NCC, respectively. 4.6. Limitations of the program The use of the program STOKER is not restricted to the case of two-cluster structures. In principle there can also be any kind of single-particle states in the cluster structures. However, the restrictions on the ~fl I

CALL OLKOAT I ./READ LNEW / ./‘READ IND. MYlAR. IEORIP/ SET POINTERS TO ZERO. SET FIRST WRITE POSITION.

INEW ‘ I IF LAST T. LASTX

T_.(_

) READ POINTERS,

/REAX ICLXS, lOPER, ICISYM, NKERN. NRAN, LASTD /

ADD BLOCK TO IWRITE~LASIT.LASTO .LAOO’.TRUE.. LASTS LAST B. PRINTER WRITE

I

IC LOS

0?

[

IF ICLSYM

0’

(

POINT5R

0?

________ _______________

F

IEOUATE POINTERS OF ICL5YM FORICLUS, OPERATOR lOPER

I

WRITE POINTERS

IF

I

REPLACE BLOCE. LADD~ FALSE.. LASTO IGNORED.

I I POINTED’ 0? TI ./PRINT WARRING

)— .#

)WRITE NK~N,NRAN

./ READ IKORN, KO, KPO.IRIT.IRI2

SF01 I

ISET ARRAYS TO ZERO. CALL /‘

PRINT MESSAGE

I

NPO L’ 0? IF I CALL BROPTE

.~~___!_(

FURTHER EXPRESSIONS

,

1 ~F

‘7

I SET ARRAYS TO ZERO, CALL GPOL ./‘PRI!T MES1AGE...~_~!_( NPO~ T ?

IF

I

I

CALL ALIONC I

ICALL BROPTE

FURTHER EXPRESSIONS? F’ I CALL ENCOON I F /‘ENOUGH SPACE BEj

___________________________

./PRINT WARRINE (ST~~)

/

\.FORE NEXT BLOCE?I WRITE GROUP OF EXPRESSIONS

__________________

I IF LAST BLOCK, I IXOJOST LAST1 )WRITE ~AST1

(

IFUOTMER 500UPS

(

I

LABB ?

IT

I

)WRITE POINTERS. LASTT.LASTX(

Fig. 4. Flow diagram of the program STOKER. The curved side boxes refer to the file KERSTO. The printing of this file status information is not indicated.

R. Krivec, M. V. Mihailovic~/ Matrix elements of two - cluster structures

168

complexity of the expresions are imposed by the subroutine GPOL (see section 4.2). For the influence of these restrictions on program PRO2C see section 5.7. It can be shown (see also section 1.1) that one of the generator coordinates can always have a fixed direction, thereby reducing the number of variables in polynomials by two. Only four variables are actually needed in the two-cluster case and 10 of the total of 12 in the three-cluster case. Such a reduction can be done in the symbolic algebra program by letting X 0, Y 0, for example, and the present program is not affected by that. In our case, the program PRO2C subroutine KER2CP skips terms having positive powers of X,Y. The variables KO and KPO are presently used as the Cartesian directions of the Ip single-particle states in the clusterings, being zero if there are only ls states. In more complicated situations, KO and KPO can denote for example particular combinations of many lp state directions, numbered in a convenient way. KO and KPO serve no purpose in the program STOKER. They are used by the program PRO2C to identify the kernels stored in the file KERSTO. =

=

4.7. Comments on symbolic evaluation of kernels A general discussion on symbolic evaluation is outside the scope of the present work. We shall comment on specific questions connected with the form of the kernels as required by the subroutine GPOL (section 4.2). To be able to substitute the exponential functions by the labels Nm, one must foresee what exponential functions can occur, and make two tables of labels and the corresponding coefficients a,~,b~,c~’(eq. (1.10)), one for the identity and kinetic energy operators, and one for the potential energy operators (see also subsection 5.4.2). As explained in section 4.2 (subroutine ALIGNC), each input polynomial must contain at least one true term beside that added (if necessary) to force the presence of brackets in (4.1). In practice we do not know in advance which of the possible exponential functions will appear in the kernel for a particular set of quantum numbers, and we must add to the true kernel an expression like X**9*(Nl+N2+

...)

where the bracket contains all possible labels from our table. Now if the exponential function N2, say, did not appear in the true kernel, we would be left with a term N2 * X * * 9 violating the requirements of the subroutine ALIGNC. All such terms must be therefore set equal to zero in the end. The character “E” which stops GPOL (see section 4.2) should actually not be followed by any character, i.e., the form “END”, or similar, is to be avoided. The reason is that “E” may appear in the column 80 of the card, and a card with characters “ND” only would confuse the reading sequence in the input. The polynomial coefficients must be numerical (section 4.2). Any overall factor not included in a particular symbolic expression can be supplied later to program PRO2C. However, all the dependence on the potential ranges cannot be factored out from the polynomial coefficients which is the reason why NRAN expressions must be supplied to the program STOKER (see section 4.3). It is advisable to keep the kernels in a completely symbolic form, and when needed substitute, by the symbolic algebra program, the range or other parameters by actual numerical values thus producing NRAN expressions from a single one. This also facilitates changing the potential parameters and replacing the blocks in the file KERSTO with new versions (section 2.1 and 4.1). The program PRO2C assumes the values of the generator coordinates are dimensionless, i.e. one should work with the variable X meaning 1/~jS~, etc. The centre of mass energy should be subtracted from the total kinetic energy kernels already in the symbolic algebra calculation. amounts to mass). an energy shift since it equals to 3/ko/4 times the identity 2$/m, where m It is the nucleon kernel (he h =

R. Krivec, M. V. Mihailovi~/ Matrix elements of two - cluster structures

169

5. Program PRO2C 5.1. General description Each run of PRO2C corresponds to given eigenvalues of J and sr, and to a specified subset of the set of operators available. Matrix elements (1.7) of the desired operators for several sets of the bra and ket quantum numbers can be calculated consecutively provided the necessary kernels (1.10) are present in the file KERSTO. For each set of quantum numbers, matrix elements for several values of generator coordinate pairs (S, S’) are calculated. The user can either just input these pairs, or else input only the values that S and S’ can assume, and require the calculation of the entire matrix with respect to the S, S’ labels, or its lower triangle. Time per matrix element is saved if the matrix elements are calculated for many (S, S’) pairs simultaneously since the program goes through the formula (1.12) only once doing partial summations for all (S, S’) pairs and all ranges at the same time. The part of the input to the program PRO2C that initiates calculations of the matrix elements consists of a sequence of an arbitrary number of cards each specifying the clustering pair (c, c’), the bra and ket states, and the sets of S and S’ values and the way the pairs should be formed. Each card is executed before the next card is read, and matrix elements are calculated consecutively for all the desired operators. The clustering pair and the operator specified, the corresponding block (see section 4.1) is copied from the file KERSTO into arrays in the program. The variable IKERN (see section 4.3) now plays the role of one of the indices of these arrays, for which reason it should be kept as small as possible. At the same time, IKERN signifies the particular set of quantum numbers pertaining to the kernel (or “group” of section 4.3) in question, in the following sense. To enable a block to contain only those groups of expressions differing essentially from one another (see section 4.1), the operators are classified into “symmetry groups” characterized by the symmetries of the matrix elements (1.10) of their members in the unprojected basis (1.2). For each symmetry group, the lower triangle (KEUP) of a matrix in the unprojected basis must be constructed and input to the program containing the pointers to the groups of expressions composing the blocks corresponding to the operators from the symmetry group. The exact nature of the pointers is to be described in section 5.4, but they are derived from the corresponding IKERN values. (They also contain information on signs and complex conjugations.) During the summation over the matrix elements (1.10) in the process of the angular momentum projection, these pointers are used to locate the required group of expressions in the program arrays containing the block transferred from the file KERSTO. A group of expressions always corresponds to fixed labels a, a” represented by the variables KO and KPO, respectively (see sections 4.1, 4.3 and 4.6). Before the information in the arrays can be used, the powers of the variables in polynomial terms have to be permuted to correspond to the labels a, a” currently needed. For example, if we have one lp state in the bra and in the ket, only the kernels with a x, a” x and a x, a” y, say, need be stored in the file KERSTO; all others needed in the course of projection differ from one of them by a permutation of powers only: the a y, a” y kernel is obtained from the first, and the a z, a” y from the second. The labels IKERN are internal to each block, i.e., the values from one block never mix with values from another one. In case two or more clustering pairs refer to the same block (see section 4.1) this rule is still obeyed although the KEUP pointers need not be exactly equal for different clustering pairs because of possible sign and complex conjugation differences. =

=

=

=

=

=

=

=

5.2. Calling sequences and description of subprograms Fig. 5 represents the calling sequences for the program PRO2C and displays the subprograms required. The main task of the program PRO2C is to perform a part of the input/output operations and to direct, accordingly to the input, the calculations of the matrix elements performed by the subroutine KER2CP,

R. Krivec, M. V. Mihailovic / Matrix elements of two - cluster structures

170

and the auxiliary calculations and operations carried out by other subprograms. We shall first describe the subprograms. BESSIP calculates the coefficients (n + k) (see ref. [2], 10.1.9, and the description of the subroutine BESVA3): CALL BESSIP (N, B) defines B(K + 1) (N + ~, K), for 0 ~ K ~ N. and ~/3SS’ in the exponential functions belonging to a FEXSET puts the coefficients of ~$S2, specified operator, for all its ranges, into the array FEXP, so that the correspondence between the symbols Nm (eq. (4.1)) and the exponential functions is as follows, up to a factor: ~,

=

~

Nm

exp[FEXP(r, m, l)~/1S2+ FEXP(r, m, 2)~/3S’2+ FEXP(r, m, 3)~f3S.S’],

where r is the index counting the ranges of the operator. The coefficients FEXP are calculated by the program PRO2C (see section 5.4.2). STFAC multiplies polynomial coefficients in the expressions for kernels processed by the program STOKER and written in the file KERSTO by overall factors mentioned in section 4.7. This can be done for each range separately. GCVAL takes two arrays containing values of the generator coordinates S and S’, respectively, and outputs arrays containing the values of S2, and SS’, respectively, for all (S. S’) pairs. The way the pairs are generated is controlled by the variable IGCWAY as follows. IGCWAY I: pairs remain as on input. IGCWAY = 2: all possible pairs are generated, corresponding to a rectangular matrix in 5, 5’ labels, 5’ running first. IGCWAY 3: the pairs in the lower traingle of this matrix are generated. ERMESS prints error messages containing error numbers and optionally stops the program. GETKER reads a block of information corresponding to a specified clustering pair and operator from the file KERSTO into the arrays in the program. Reading is performed in the same fashion as writing in the program STOKER. If IPO = 0 is returned, the required block was not found. DECODN performs the reverse function to the subroutine ENCODN (see section 4.2). It is called by GETKER. IND3D converts three indices into one and is employed to avoid arrays with more than three indices. IVAL (see section 4.2). RVAL (see section 4.2). KER2CP is the principal subroutine in the program. It employs the formula (1.12) to calculate the matrix elements of any operator for a specified set of (S, S’) pairs. The coefficients (1.13) are input to ~t2

=

=

I

i~~iTj—.

—I

PRR2C

UFAC

I

LEx5tTØ~~su:::0

I

6CVAL

__

~

I I

IVAL

1/

__

GEIKER

\

~

I__RSCRO

\ ~

__

RVAL

\,~

LDECBDN 1~~BESSEL ~BESYA3 IND3D

L

RSCRI

CLEO

RISCOT

KER2CP ~PBW5EN

ATOCO__~1

DRT

~...4

ORZ

ORLA

‘f1

003

~

Fig. 5. Calling sequences of the program PRO2C.

~LARAN

I

004

I

R. Krivec, M. V. Mihailovi~/ Matrix elements of two - cluster structures

171

KER2CP. The generator coordinates are put parallel to the z-axis and the terms in the kernels with S~and to positive powers are skipped. Intermediate sums in eq. (1.12) are performed for all (S, S’) pairs and all ranges simultaneously. The Bessel functions ~ are calculated immediately after the sum over p in eq. (1.12) for all products SS’, all ranges and all indices A required, since each Bessel function is used more than once in the internal sums. These two parts of the calculation are the only ones whose time consumption depends on the number of (S, S’) pairs. The explanation of the arguments of KER2CP in its header helps clarify the meanings of the chief arrays and variables in the program. The present version of KER2CP is limited to not more than one lp state in each of the bra and ket states. See section 5.7. BESVA3 outputs a set of values of the modified spherical Bessel functions of the first kind, i.e. i~(x) ~ir/2x I~i/.~(x),(see ref. [2], 10.2.2) for all A up to a specified maximum, and for arguments obtained as all possible products of the elements of two input arrays. (In our case the arrays are FEXP (see description of subroutine FEXSET) and the products SS’.) A REAL variable BCRIT must be input. For each argument x, if IxI ~ BCRIT, BESVA3 calls the routine BESSEL that calculates i~(x).If IxI> BCRIT, BESVA3 employs the formula (ref. [2], 10.2.9) =

=

~—{R(A +

~,

—x) ex

—

(~

l)XR(A +

~,

x) e~],

(5.1)

where (ref. [2], 10.2.11) A ~

and calculates e_xix(x) rather than j~(X). The argument x is returned in that case and later added to the argument of the exponential function in eq. (1.12). BESSEL calculates ix(x). ADDCO is an auxiliary routine for adding terms to intermediate sums in KER2CP, for all (S, S’) pairs and all ranges. ADDC1 is similar to ADDCO. DRLA and the associated subprograms DR 1, DR2, DR3 and DR4 form a package for calculating the values of the expressions 2A+ I

~

(1

+

8~A+I)

~i(L, M, N; k, q; A, ~s)~(L’, M’, N’; k’, q’; A,

fA)

I

~

in eq. (1.12) using the integrals over spherical angles (3.1) and (3.2) calculated and written to the file INTSTO by the program DFIDTH. The program that references DRLA (in our case KER2CP) reads the appropriate parts of information from the file and passes it to DRLA through COMMON. These parts are the XDFI and XDTH blocks of program DFIDTH. There is only one XDFI block read in by the program PRO2C before KER1CP is called. Two XDTH blocks are required and read by KER2CP and are specified uniquely by the values of L, M, N, and L’, M’, N’, respectively. The integrals ~ are expressed by the integrals (3.1) and (3.2) in the following way: ~ L M N’ k (

,q,

A

~

2k + 1 2A21T + I (k (k + [q])! [q])! (A (A + [it])! [EL])! 1/2 2i~ XD,,(k, [q]; A, [es]; L + M, N)D,~,’)(L,M, [~.tJ, [q]),

— ~—

—‘

1

Iql+lY’l

—

—

172

R. Krivec. M. V. Mihailovic

/ Matrix elements of two

-

cluster structures

where [q] q if q ~ k, and [q] q k 1 if q> k, and analogously for ~s,A. Four cases are distinguished, each corresponding to one of the routines DR1 to DR4 as follows: =

=

—

—

(i)l~~A, l~
(ii)l~t~A,

k+l~q~2k+l,

~=DR2;

~ (iii)A+l~s~2A+l, 1~q~k,

(iv)A+l~t~2A+l,

~=DR3;

k+1~q.~2k+l,

çi=DR4;

LARAN determines the range of values of the index A in eq. (1.12). POWGEN performs permutations of powers of variables in polynomials as mentioned in section 5.1. Let the original powers of the six variables be (1, 2, 3; 4, 5, 6). Then if for the original kernel a x, a” = x, the powers (3, 1, 2; 6, 4, 5) are returned for the kernel a =y, a” =y. If the original kernel had a x, a” y, the powers returned for the kernel a = z, a” x would be (2, 3, 1; 5, 6, 4). The present version of POWGEN is limited to at most one lp state in the bra and in the ket (see section 5.7). RSCEV1 forms the set of coefficients (1.13) required for the calculation of matrix elements of any operator, with quantum numbers fixed. The arguments are explained in the program text. The restriction is to at most one Ip state in the ket (see also section 5.7). RSCRO calculates (upon a call from RSCEV1) the ceofficient (1.13) when there are only ls states in the ket. RSCR1 calculates (upon a call from RSCEV1) the coefficient (1.13) when there is one lp state in the ket. It contains the matrix of coefficients to express the rotation matrix elements for Cartesian vectors, to which ~ eq. (1.8), reduce in this case, in terms of the SD-functions. CLEB is a routine for Clebsch—Gordan coefficients. When it is called for the first time, it calculates 100 factorials for internal use. RISCO 1 determines whether a particular coefficient (1.13) is real or imaginary. Restrictions are as for RSCEV1. RESPR1 prints the results for a given set of quantum numbers. If required, it also writes the identity and Hamiltonian matrix into a file. SUMLAB takes as input the symmetry matrix KEUP discussed in section 5.1, and the quantum numbers of the matrix element to be calculated. It outputs an array specifying the groups of expressions to be used in the summation over the unprojected states in eq. (1.12) in subroutine KER2CP. Pointers to the groups are their respective IKERN labels. The output is derived from the row of KEUP defined by the bra unprojected state and is contracted for nonexisting kernels. A detailed explanation is to be found in the comment in the program text, or in section 5.4. XFAC (see section 3.2). =

=

=

=

5.3. COMMON statements A blank COMMON area required by the function DRLA is declared in the program PRO2C, and in the subprograms KER2CP, DRLA, DRI, DR2, DR3, and DR4. The reader should refer to function DRLA and program DFIDTH for explanation of dimensions in COMMON.

R. Krivec, M. V. Mihailovi~/ Matrix elements of two - cluster structures

173

5.4. Description of input Apart from the files KERSTO and INTSTO, there are three input units to the program PRO2C (fig. 1). Their unit numbers LFNSTA, LFNEXP and LFNDAT, are initialized to 2, 3 and 4, respectively, by a DATA statement in PRO2C. First the entire input from LFNSTA is read, then so from LFNEXP and finally from LFNDAT. Consequently the units can be merged into two or a single one, changing at the same time the unit numbers correspondingly. The first card of input from each unit controls the printing of the input data. As the number of cards on any unit depends on the problem, we group below the input cards according to the read statements, and give descriptions for each group. Care must always be exercised that the input to PRO2C is compatible with the information available in the files KERSTO and INTSTO. 5.4.1. Input from unit LFNSTA Data on this unit need change only if a new operator is added to the Hamiltonian, or a new clustering structure is introduced. Groups of cards are as follows. 1. (LI) Printing control. If .TRUE. (T), the input will be printed. 2. (14) NCLUS, number of clustering pairs (c, c’) (in the lower triangle in c, c’ labels). 3. (314, 4A4) NCLUS cards, each containing: clustering pair number (between 1 and NCLUS), cluster structure numbers in the bra and ket, clustering pair description. 4. (214) Number of operators (NOPER), number of “symmetry groups” of operators (see section 5.1) (NOPSY). 5. (214, 4A4) NOPER cards, each containing: operator number (between 1 and NOPER), symmetry group number of the operator, the operator description. Operator no. 1 must be the identity, and operator no. 2 must be the kinetic energy. This convention is imposed by the subroutine FEXSET. 6. (2014) NCLUS cards, each containing: clustering pair number, and as many further items as there are operators. These items are the maximal sums of powers of the components of the ket generator coordinate, S~,S and S~,in the expressions for the corresponding kernels and serve to determine the maximal A for the Bessel functions ~~(X). They are connected with the program DFIDTH input parameters. 7. (14) Number of cards in group 8 (NSTA). 8. (514) NSTA cards each defining a subset of quantum numbers of a particular angular momentum and parity projected state (1.3) that can subsequently be referred to by a single number. Each card contains: the subset (or state) number, twice the K value, twice the I value, twice the p value, and the Cartesian direction of the ip state (zero if absent, 1 for the x direction, etc.); see eq. (1.3). This form of describing states is in accord with the program PRO2C limitations; see section 5.7. Double values of quantum numbers avoid using REAL arithmetic in case of half-integer values. This group of cards defines all states that can subsequently enter the calculated matrix elements, and facilitates calculations if the selection rules are already built in it. 9. (14) Number of cards in group 10 (NUPST). 10. (514) NUPST cards each containing the set of labels of a particular unprojected state (1.2). The kernels (1.10) corresponding to pairs of these states should be present in the file KERSTO. Each card contains: the set (or state) number, clustering number (c), twice the I value, twice the v value, the Cartesian label a. (Compare group 8.) For the Cartesian label see the description of KO, KPO in section 5.1. 11. Next, NOPSY groups of cards follow. Each of them is composed as follows: 11. 1. (214) Symmetry group number (IOPSY), number of pointers to follow (NPNTR). 11. 2. (2014) A group of cards each containing 10 (or less if the last card) pairs (position, pointer). Pointer

R. Krivec, M. V. Mihailovi~/ Matrix elements of two - cluster structures

174

is an element of the array KEUP (see section 5.1) containing the row-wise arranged lower triangles of symmetry matrices in the unprojected basis: pointer KEUP (position, IOPSY). The pointer is a modified value of the kernel label IKERN (see section 5.1), as follows. If the kernel corresponding to a particular position in KEUP is equal to plus (minus, plus complex conjugate of, minus complex conjugate of) the kernel having the label IKERN and being stored in the file KERSTO, then its pointer is IKERN IKERN, 100 + IKERN, 100 IKERN). Pointers to zero kernels are zero (and skipped by the subroutine SUMLAB). As the needed parts of the array KEUP are set to zero before reading the pointers, only nonzero pointers need be defined by this input card group. =

(—

—

—

Input from unit LFNEXP Data residing on this unit are subject to changes either in the case mentioned in the subsection 5.4.1, or if the parameters of the operators are changed (in the latter case one must be especially careful that the corresponding changes are also made in the file KERSTO). 5.4.2.

1. (Li) Printing control. If .TRUE. (T), all the input on this unit will be printed, otherwise only the parameters of the potentials. 2. (F8.2) Oscillator parameter (fm2) as defined in eq. (1.1). 3. (E20.l3) Overall factor to multiply the identity operator kernels (see section 5.2, subroutine STFAC). 4. (E20. 13) The same for the kinetic energy kernels. 5. (14) Number of different exponential function labels occurring in the identity (or kinetic energy) operator kernels for all clustering pairs together (NFCN). 6. (14) NOM (see below). 7. (514) NFCN cards each containing: label number (between 1 and NFCN), label, NUM1, NUM2 and NUM3. The reason the program distinguishes the label number from the label itself is that the user might not know in advance which exponential functions would occur in the actual kernels, thereupon preparing a too long table of labels and the corresponding coefficients FEXP (see section 5.2). He may later delete unused table entries without changing the remaining labels. The program PRO2C calculates the coefficients FEXP for the identity and kinetic energy but stores them not by labels, but by label numbers, into the array FEXPN: $

FEXPN(ln, k) = FLOAT(NUMk)/FLOAT(NOM) so that the exponential function is exp[FEXPN(ln, i)~$S2+ FEXPN(ln, 2)~$S’2+ FEXPN(ln, 3)~$S.S’], where ln is the label number. What follows will be read only if NOPER> 2 (i.e., if there is some potential energy operator). 8. NOPER 2 groups of cards follow, each composed as indicated below. 8. 1. (214) Operator number (lOPER), number of ranges (NRAN). 8. 2. (14, 2E20.l3) NRAN cards each containing: range number (between 1 and NRAN), overall factor (see section 5.2, subroutine STFAC), range (in fm, as defined in eq. (1.5)). 9. (14) Number of different exponential function labels occurring in the potential energy operator kernels for all clustering pairs together (NFCV). 10. (14) NOM (see below). 11. (814) NFCV cards each containing: label number (between 1 and NFCV), label, NUM1. NUM2, NUM3, NUMR1, NUMR2, NUMR3. (Compare the comment on the group 7 above.) The program PRO2C calculates the coefficients FEXP for the potential energy operators, and stores them as follows: —

FEXPV(r, ln, k)

=

(FLOAT(NUMk)

+

RAEX(r)FLOAT(NUMRk))/FLOAT(NOM),

R. Krivec, M. V. Mihailovü~/ Matrix elements of two-cluster structures

175

so that the exponential function is exp[FEXPV(r, ln, 1)~$S2+ FEXPV(r, ln, 2)~$S’2+ FEXPV(r, ln, 3)~$S.S’], where ln is the label number, r is the range number, and RAEX(r)=(2+$p~)’, where

$

is the oscillator parameter (see group 2 above) and Pr

1S

the range (see group 8.2 above).

5.4.3. Input from unit LFNDA T This unit contains data specifying the calculations to be carried out. 1. (Ll) Printing control. If .TRUE. (T), part of the input (up to, and including, group 6) will be printed out during reading. Otherwise only the data from group 4 will be printed. Data to which the printing control does not apply are printed together with the values of matrix elements. 2. (2014) One or more cards, the first containing NSSET, the number of generator coordinate sets of values, as the first item. This is followed by NSSET items (if necessary continued on further cards) specifying the numbers of values in each set. 3. Next, NSSET groups follow, each consisting of one or more cards containing the corresponding number of generator coordinate values in format (10F8.2). The values should be in fermi units. They are subsequently multiplied in the program by ~ 4. (514) JMX, MICX, LCX, LAX, LMX. These are the parameters of the DFIDTH run which generated the file INTSTO to be used in calculations. 5. (F8.2) BCRIT. See section 5.2, subroutine BESVA3. BCRIT can be small (less than about 1.0) since the use of formula (5.1) is faster than the use of routine BESSEL. 6. (214) J2, IPAR, where J2 is twice the total angular momentum valid for the entire run, and IPAR is a number of the same parity as the physical parity to be projected (IPAR is used only as MOD (IPAR + ..., 2)). 7. (8OLl) 1 + NOPER items, the first controlling the writing of matrix elements into a file of card images (see subsection 5.6.2). Other items control the calculation of matrix elements of various operators. All items remain valid for the entire run. 8. Next a group with any number of cards follows, each defining the matrix elements to be calculated. The calculation is carried out before the next card is read. The last card should have a zero in the first position (ICLUS 0, see below) to stop the program. Card format is as follows: 8. 1. (614) Clustering pair number (ICLUS), bra projected state number (IBRA), ket projected state number (IKET), bra generator coordinate set (IBRASS), ket generator coordinate set (IKETSS), parameter IGCWAY (see section 5.2, subroutine GCVAL). ICLUS refers to numbers read in group 3 on unit LFNSTA. IBRA and IKET refer to state numbers read in group 8 on unit LFNSTA. IBRASS and IKETSS are sequential numbers of card groups described in group 3 on unit LFNDAT. =

5.5. Program flow diagram This is shown in fig. 6. Important steps are presented only. They can be understood from sections 5.2 and 5.4. 5.6. Description of output 5.6.1. Printed output (unit LFNPR) LFNPR is initialized to 6 in a DATA statement in PRO2C.

R. Krivec, M. V. Mihailovic~/ Matrix elements of two-cluster structures

176

During reading of the input, the main program prints the input data if required (section 5.4). Subroutine RESPR1 prints the results of calculations initiated by a card from group 8 on unit LFNDAT (see subsection 5.4.3). First the clustering pair description, the quantum numbers and the values of $ and BCRIT are printed, followed by real and imaginary parts of matrix elements of the Hamiltonian, the identity operator and all the separate operators specified in the input. The matrix elements are accompanied by the generator coordinates and the ratios of the Hamiltonian to the identity matrix elements (in MeV). 5.6.2. Results in a file (unit LFNP UN) LFNPUN is initialized to 7 in a DATA statement in PRO2C. The file is written if required (see group no. 7 on unit LFNDAT, subsection 5.4.3). Format conversions are employed to produce records as 80 column card images. The first record, formatted (4A4, 2X, 212, 2X, 412, 2X, 412, FlO.4), contains the clustering pair description, 2J, IPAR (see subsection 5.4.3), 2K, 21, 2p, a, 2K’, 21’, 2v’, a’ (see eq. (1.9)), and the oscillator parameter Each of the records following contains, in format (14, 4E 19.12), the sequential number of the (S. S’) pair, and the real and imaginary parts of the identity and Hamiltonian matrix elements corresponding to that (S, 5’) pair. Informative messages are provided (see fig. 6) if SUMLAB does not find the unprojected states to be summed over in the projection, and if GETKER does not find the block required in the file STOKER. A fatal message occurs if the number of (S, S’) pairs generated (subroutine GCVAL) exceeds the corresponding dimensions. $.

5.7. Limitations of the program

The program is written for at most one ip single-particle state in any cluster structure. Another restriction is to states without intermediate spins J’~ (see eq. (1.2)). One way to remove the first restriction is as follows.

SA READING FROM UNIT LFNSTA READING FROM UNIT LFI OP ADIN PRO UNIT LF DAT GENERATE FACTORIALS REAO INTEGRALS 000FI FROM FILE INTSTO REAT ICLUS IBRA IKET STOP

T

CALL RVAL

PRINT MESSAGE

ICIUS

BRASS IKETSS IGCWAY 0’

CALL CALL CALL T

SCYAL RSCEMT BESSIP LYFO R

CAL

SUWLAO

LT 00

RUPSO ~O CALL GETKER BLOCK EXISTS ? A

F

PRINT MESSAGE

ET

CALL 0 R

P

FURTNEM OPERATORS’ ALL RESPR

Fig. 6. Flow diagram of the program PRO2C.

R. Krivee, M. V. Mihailovi~/ Matrix elements of two - cluster structures

177

(i) The variables KO and KPO in programs STOKER and PRO2C (see sections 4.3, 4.6 and 5.1) should stand for a set of Cartesian state labels. The related variables in PRO2C are KD, KDPP and the array KDX, and in KER2CP, KD, KDP and KDX. (ii) In PRO2C, the calculation of auxiliary variables LSUM = s, LPSUM = s’ (see eq. (1.3)) should be changed appropriately. (iii) The subroutine RSCEV1 and its called subroutines calculating the coefficients (1.13) should be replaced by less restricted versions. The second index of the array RSC and the first index of the array IRSCRI should be generalized (see PRO2C, KER2CP and RSCEV1). (iv) The subroutine POWGEN should be generalized. (v) Some comments should be changed in various programs. Note that with the increasing complexity of the problem the restrictions imposed by GPOL (see section 4.6) could be approached. The restriction to not more than 100 different exponential function labels could be overcome by separating the calculations with PRO2C for different clustering pairs, so that labelling could start from I for each clustering pair. If that were not enough an amendment of GPOL would seem inevitable in case such tricks as dividing the expressions into several parts were not employed. If two-digit powers of variables in polynomials appeared, introducing new or additional variables could reduce powers, but their interpretation in PRO2C would also change. The second above limitation of PRO2C could be overcome by adding another label to the unprojected and projected states (arrays IUPST and ISTATE) read from unit LFNSTA. This label, standing for the intermediate spin I~(or a combination of them) is only needed in the subroutine SUMLAB to recognize states (the affected IF statements in SUMLAB should be changed). (It enters implicitly into the selection rules hidden in the symmetry matrices KEUP (sections 5.1 and 5.4.1), but this has no effect on the program.)

6. Test run descriptions As an example, the cluster structure (4 He—2 H) of the nucleus 6Li is treated. Each of the programs DFIDTH, STOKER and PRO2C is run once. The output of DFIDTH is self-explanatory. STOKER processes the matrix elements of Volkov [4] V2 central potential (“CASE 1”), of the identity operator (“CASE 2”) and of the kinetic energy operator (“CASE 3”). All of these are diagonal in spin quantum numbers and independent of these on the diagonal, so that only one expression exists for any one of them. Program PRO2C calculates a set of kernels for the Hill—Wheeler equation for the specified quantum numbers. The second case treated by PRO2C is chosen such that it produces a warning (calculation of matrix elements identically zero is required). Not reproduced are the input data listed by PRO2C.

Acknowledgements The present authors would like to thank Professor G. Schatz for hospitality at the Institut für Angewandte Kemphysik, Kernforschungszentrum Karlsruhe, where the original versions of several programs were written. They are grateful to Dr. R. Beck and Dr. F. Dickmann for discussions. The GPOL subprogram package was originally written by 0. Zagorc. It was put into the present form by Miss R. Kuhn. Subprogram CLEB was obtained from Professor M. Rosina and had been originally written at the University of California at Davis.

R. Krivec, M. V. Mihailovic / Matrix elements of two - cluster structures

178

References [1] [2] [3] [4]

M.V. Mihailovk and M. Poljiak, Nucl. Phys. A3l 1(1978) 377. M. Abramowitz and l.A. Stegun, Handbook of Mathematical Functions (Dover, New York, 1970). B.C. Karp and JR. Comfort, Comput. Phys. Commun. 23 (1981) 355. A.B. Volkov, Nuci. Phys. 74 (1965) 33.

R. Krivec, M. V. Mihailovh~/ Matrix elements of two-cluster structures

TEST RUN OUTPUT Output from DFIDTH INPUT PARAMETERS WERE JMX

MICX

LCX

3

9

5

LAX

FAC1~RIALS XE

XDF

9

22

XDFI VALUES TM THE FILE

54 XDTH VALUES IN THE ~ILE IN ONE BLOCK 225 NUMBER OF XOTH BLOCKS 6

LMX

179

180

R. Krivec, M. V. Mihailovi~/ Matrix elements of two - cluster structures

Output from STOKER FILE CREATION RUN.

CASE

1

ICLUS • 1 LASTB •

lOPER 3 TCLSYM 0 MKEPM 1 N~’.AN = 7 (BLANK WORDS APPENDED IF ADDING THE BLOCK)

ADDING A NEW BLOCK. WRITING STARTS AT WORD IKERN 1 KO 0

39. K~O • 0

IRI1

1

1R12

=

1

NEW OR OLD BLOCK ~CINTERS (I~LDO)D CLUSTERING PAIR

1

2

1 2 3 4

0 0

0 0

3

5

I)

6

3

0 0 0

o

LAST WORD OF INFORtIATItIH + 3. BLANK WORDS TO BE APPENDED CASE

OPERATOR 1

4

5

6

3’~ 0

0

0 0

0 0

0 ‘3 0

0 0 ‘3

0 0

0 0

0

1

o

o

o

o

10)

2

ICLUS 1 LASTB •

I~J’~EP I ICLIYM 0 ‘IKEP’~ = 1 N~A’~ = 5 (BLAN~( ‘4O’~DS AP~EMDED IF ADDIN 1H2 3LOCK)

ADDING A NEW BLOCK. WRITING STARTS AT WORD IKERN = 1 1(0 = 3

107. KP) = ‘1

I°.1

=

1

IRI~ = 1

NEW OR OLD BLOCK PCIMTERS (I3LPO):

CLUSTERING PAIR 1 2 3 4 5 6

1

2

107 0 3 ‘3 3 3

0 0 0 0 0 0

LAST WORD OF INFORMATI0’~+ 1. BLANK WORDS TO BE APPENDED

OPERATOR 3

4

5

6

30 0 ‘3 ‘3

Q ‘3 0 ‘3

1)

0 0 0 0

0

0

o

130 5

0 0 0 0 C

‘1

‘3

R. Krivec, M. V. Mihailovi~/ Matrix elements of two - cluster structures CASE

3

ICLUS

1

•

I.]PER

LASTB

10

•

ICLSYM

.2

0

HKER~I

•

1

~1RAN•

(BLANK WORDS AP’ENDED IF ADDING THE BLOCK)

ADDING A FlEW BLOCK. WRITING STARTS AT WORD IKERN • 1 KO •

(3

135. KOD = 0

IRI1

=

1

1R12

=

1

NEW OR OLD BLOCK POINTERS (I~1LPJ):

CLUSTERING PAIR 1 2 3 4 5 6

1

2

107 0 0 0

135

39 (3 0 0 ‘3 0

0 0 0

1)

0

0

LAST WORD OF INFORMATION + 1 BLANK WORDS TO BE AP~ENDED CASE

OPERATOR. 3

4

5

6

‘3 ‘3 0 0 3 ‘3

(3 0 (3 ‘3 0 0

0 (3 0 0 0 (3

212 13

4

ICLUS = 0 LASTB •

IOPEP • ‘3 TCLSYM 0 NKER~l 5) MRAN 0 (BLANK WORDS AP~ENDED IF ADDING TI-IE BLOCK)

•

0

EXITING. HEADER REWRITTEN AS FQLLO’IS: NEW BLOCK POINTERS (IBLPO): CLUSTERING PAIR 2. 2 3 4 5 6

1 107 3 0 0 ‘3 ‘3

LAST WORD OF INFORMATION + 1 BLANK, WORDS TO BE APPENDED END OF RUN.

OPERATOR 3

2 3.35 0 0 0 0 0

39 3 0 0 0 0 212 10

4

9

6

0 3 ‘3 C) 3 ‘3

0 0 0 0 0 3

(3 I)

0 0 0 0

181

/

R. Krivec, M. V. Mihailovi6

182

Matrix elements of two - cluster structures

Output from PRO2C CLUSTER ING

(4HE—2H, 4HE—7H)

,3, PARITY

1

INT. Z—COMP. TOTAL SPIN SPIN MAC. C. CART. LABEL

BRA 1 1 1 C)

BETA BCRIT

,

+

KET

a 1 C C

.4489 .50

EVALUATED

I

COUNT I S~’ RE(HlI) IM(H/I) 1 .10 —20.47 2 3.00 —27.57 3 3.00 —29.72 4 5.00 —42.56 5 5.00 —35.23 6 5.00 —30.72

.10 0.30 .10 0.03 3.CO C.00 .10 0.00 3.00 0.30 5.00 0.03

‘IA’IILT’3ITAN RE IM RE IM P.O IM RE 1’ T’E

131 ~E 131 RI 131 RE 131

7 7.00 .10 —69.30 0.00 9 7.00 3.00 —51.63 0.00 9 7.00 5.00 P0 —35.66 0.00 IM 10 7.00 7.00 RE —29.86 0.00 131 11 10.00 .10 RE —134.82 0.00 JM 12 10.00 3.00 RE —97.75 0.00 131 13 10.00 5.00 RE —64.64 0.00 131 14 10.00 7.00 RE —42.45 0.00 Iti 15 10.00 10.00 RE —30.05 0.00 I~’

I

T

I’3E~lTITY KINETIC tNERGV

CCNT~’A1 PET.

—.205671020—0’, .100454560—05 0. 0. —.6494’3’2~E—0’ .‘35’~6”14E—’33 0. 0. —.202’t~l13E+01 .705148”4E—Ol 0. 0. —.25426032E—02 .5)71’1514E—04 0. 0. _.9768015”0+0) .277’.~501t—01 n. )..2350(12310—01 0+0O —.‘271’s713 ‘3. 0. —.223(3’,137E—03 .322’3’32170—05 0• 0. —.1493972’IE+Ol .280165230—02 ‘3. 0.

.300223050—04

—.10~3S02OE—C3

0•

.17075795E—C1 0. .47’3’37435+01 0. .32020043E—02 0. .149407770+01 a..1249C034E+01 (3. .657221430—04 0. .91306~90E—01 0.

—.2437C768E—C1 0. —.60143748F4C1

0. .651796470—02

—.24’O~”7~E+C1 0. —.19711456E+C1 0. —.28906’sS2E—C3 0. —.242094C8E+CC 0. .31~T73~6E+CO —. 562~9~2E+CC 0. 0. .337077(330+00 —.s31546e7F+OC

0.

0.

0.

—.16’7C2300—O6 0. —.176249910—03 0. .251672240—02

—.269C0462E—’3~

—.1u7379790—02 ‘3. —.960763020—02

.32070~44E—’3(1 0. .109”9408E—04 0. .14953937t—03

‘3.

0.

0.

0.

_.359449100_01 0. —.496522470—01 0.

.8466744”E—03 0. .161181HE—02 0.

.331191490—01 0. .B13fl’~26E—01 0.

—.69064C58E—C1 0. —.13205217E+CC 0.

—.74497186’+Oi

0. —.1144.SV)40+01 3. —.43170’72E—06 (3.

.686~041’3t—02

—.5745112~E—P2 (3.

0.

—.80’047G6E—03 0.

—.121243~3E—C1