~maddevelopers/mg5amcnlo/new_clustering : revision 356

madgraph/iolibs/template_files/bornmatrix_splitorders_fks.inc

SUBROUTINE SBORN(P,ANS_SUMMED)

%(info_lines)s

C Return the sum of the split orders which are required in orders.inc (BORN_ORDERS)

C Also the values needed for the counterterms are stored in the C_BORN_CNT common block

%(process_lines)s

C CONSTANTS

implicit none

include 'nexternal.inc'

INTEGER NAMPSO, NSQAMPSO

PARAMETER (NAMPSO=%(nAmpSplitOrders)d, NSQAMPSO=%(nSqAmpSplitOrders)d)

INTEGER NGRAPHS

PARAMETER (NGRAPHS= %(ngraphs)d)

C ARGUMENTS

REAL*8 P(0:3,NEXTERNAL-1)

C VARIABLES

INTEGER I,J,K

include 'orders.inc'

double precision ans_summed

COMPLEX*16 ANS(2,0:NSQAMPSO), ANS_CNT(2, NSPLITORDERS)

LOGICAL KEEP_ORDER(NSQAMPSO), KEEP_ORDER_CNT(NSPLITORDERS, NSQAMPSO), FIRSTTIME

data keep_order / NSQAMPSO * .TRUE. /

common /c_keep_order_cnt/ keep_order_cnt

common /c_born_cnt/ ans_cnt

integer ord_subtract

data firsttime / .TRUE. /

integer amp_orders(nsplitorders)

double precision tiny

parameter (tiny = 1d-12)

double precision max_val

double precision wgt_ME_born,wgt_ME_real

common /c_wgt_ME_tree/ wgt_ME_born,wgt_ME_real

double precision amp2b(%(ngraphs)d), jamp2b(0:%(ncolor)d,0:nampso)

common/to_amps_born/ amp2b, jamp2b

Double Precision amp2(%(ngraphs)d), jamp2(0:%(ncolor)d)

common/to_amps/ amp2, jamp2

logical split_type_used(nsplitorders)

common/to_split_type_used/split_type_used

C FUNCTIONS

integer GETORDPOWFROMINDEX_B

integer orders_to_amp_split_pos

C BEGIN CODE

C look for orders which match the born order constraint

if (firsttime) then

do i = 1, nsqampso

C this is for the orders of the born to integrate

do j = 1, nsplitorders

if(GETORDPOWFROMINDEX_B(j, i) .gt. born_orders(j)) then

keep_order(i) = .false.

EXIT

endif

enddo

C this is for the orders of the counterterms

do j = 1, nsplitorders

keep_order_cnt(j,i) = .true.

do k = 1, nsplitorders

if (j.eq.k) then

ord_subtract=2

else

ord_subtract=0

endif

if(GETORDPOWFROMINDEX_B(k, i) .gt. nlo_orders(k)-ord_subtract) then

keep_order_cnt(j,i) = .false.

EXIT

endif

enddo

if (keep_order(i)) then

write(*,*) 'BORN: keeping split order ', i

else

write(*,*) 'BORN: not keeping split order ', i

endif

enddo

do j = 1, nsplitorders

write(*,*) 'counterterm S.O', j, ordernames(j)

do i = 1, nsqampso

if (keep_order_cnt(j,i)) then

write(*,*) 'BORN: keeping split order', i

else

write(*,*) 'BORN: not keeping split order', i

100

endif

101

enddo

102

enddo

103

firsttime = .false.

104

endif

105

106

CALL SBORN_SPLITORDERS(P,ANS)

107

108

C the born to be integrated

109

ans_summed = 0d0

110

max_val = 0d0

111

112

C reset the amp_split array

113

amp_split(1:amp_split_size) = 0d0

114

amp_split_cnt(1:amp_split_size,1:2,1:nsplitorders) = dcmplx(0d0,0d0)

115

116

do i = 1, nsqampso

117

max_val = max(max_val, abs(ans(1,I)))

118

enddo

119

do i = 1, nsqampso

120

if (keep_order(i)) then

121

ANS_SUMMED = ANS_SUMMED + ANS(1,I)

122

C keep track of the separate pieces correspoinding to different coupling combinations

123

do j = 1, nsplitorders

124

amp_orders(j) = GETORDPOWFROMINDEX_B(j, i)

125

enddo

126

if(abs(ans(1,i)).gt.max_val*tiny) amp_split(orders_to_amp_split_pos(amp_orders)) = ans(1,i)

127

endif

128

enddo

129

C this is to avoid fake non-zero contributions

130

if (abs(ans_summed).lt.max_val*tiny) ans_summed=0d0

131

132

wgt_me_born=ans_summed

133

134

C fill the amp2 and jamp2 arrays

135

amp2(1:ngraphs)=amp2b(1:ngraphs)! amp2 just needs to be copyed

136

137

do i = 0, int(jamp2b(0,0))

138

jamp2(i)=0d0

139

do j = 1, nampso

140

c here sum all, this may be refined later

141

jamp2(i)=jamp2(i)+jamp2b(i,j)

142

enddo

143

enddo

144

145

%(skip_amp_cnt)s

146

C quantities for the counterterms

147

do j = 1, nsplitorders

148

ans_cnt(1:2,j) = (0d0, 0d0)

149

if (.not.split_type_used(j)) cycle

150

do i = 1, nsqampso

151

if (keep_order_cnt(j,i)) then

152

ANS_CNT(1,j) = ANS_CNT(1,J) + ANS(1,I)

153

ANS_CNT(2,j) = ANS_CNT(2,J) + ANS(2,I)

154

C keep track of the separate pieces also for counterterms

155

do k = 1, nsplitorders

156

amp_orders(k) = GETORDPOWFROMINDEX_B(k, i)

157

C take into account the fact that the counterterm for a given split order

158

C will be multiplied by the corresponding squared coupling

159

if (k.eq.j) amp_orders(k) = amp_orders(k) + 2

160

enddo

161

C this is to avoid fake non-zero contributions

162

if (abs(ans(1,I)).gt.max_val*tiny) amp_split_cnt(orders_to_amp_split_pos(amp_orders),1,j) = ans(1,I)

163

if (abs(ans(2,I)).gt.max_val*tiny) amp_split_cnt(orders_to_amp_split_pos(amp_orders),2,j) = ans(2,I)

164

endif

165

enddo

166

C this is to avoid fake non-zero contributions

167

if (abs(ans_cnt(1,j)).lt.max_val*tiny) ans_cnt(1,j)=(0d0,0d0)

168

if (abs(ans_cnt(2,j)).lt.max_val*tiny) ans_cnt(2,j)=(0d0,0d0)

169

enddo

170

171

172

999 return

173

END

174

175

176

177

SUBROUTINE SBORN_SPLITORDERS(P1,ANS)

178

179

%(info_lines)s

180

181

C RETURNS AMPLITUDE SQUARED SUMMED/AVG OVER COLORS

182

C AND HELICITIES

183

C FOR THE POINT IN PHASE SPACE P1(0:3,NEXTERNAL-1)

184

185

%(process_lines)s

186

187

IMPLICIT NONE

188

189

C CONSTANTS

190

191

include "nexternal.inc"

192

include "born_nhel.inc"

193

INTEGER NCOMB

194

PARAMETER ( NCOMB= %(ncomb)d )

195

INTEGER NAMPSO, NSQAMPSO

196

PARAMETER (NAMPSO=%(nAmpSplitOrders)d, NSQAMPSO=%(nSqAmpSplitOrders)d)

197

INTEGER THEL

198

PARAMETER (THEL=NCOMB*%(nconfs)d)

199

INTEGER NGRAPHS

200

PARAMETER (NGRAPHS= %(ngraphs)d)

201

202

C ARGUMENTS

203

204

REAL*8 P1(0:3,NEXTERNAL-1)

205

COMPLEX*16 ANS(2,0:NSQAMPSO)

206

207

C LOCAL VARIABLES

208

209

INTEGER IHEL,IDEN,i,j,jj,glu_ij

210

REAL*8 borns(2,0:NSQAMPSO)

211

COMPLEX*16 BORNTILDE

212

INTEGER NTRY(%(nconfs)d)

213

DATA NTRY /%(nconfs)d*0/

214

COMPLEX*16 T(2,NSQAMPSO)

215

INTEGER NHEL(NEXTERNAL-1,NCOMB)

216

%(helicity_lines)s

217

%(den_factor_lines)s

218

%(ij_lines)s

219

220

C GLOBAL VARIABLES

221

222

Double Precision amp2(ngraphs), jamp2(0:%(ncolor)d,0:NAMPSO)

223

common/to_amps_born/ amp2, jamp2

224

DATA jamp2(0,0) / %(ncolor)d/

225

LOGICAL GOODHEL(NCOMB,%(nconfs)d)

226

common /c_goodhel/goodhel

227

double complex saveamp(ngraphs,max_bhel)

228

common/to_saveamp/saveamp

229

double precision savemom(nexternal-1,2)

230

common/to_savemom/savemom

231

double precision hel_fac

232

integer get_hel,skip(%(nconfs)d)

233

common/cBorn/hel_fac,get_hel,skip

234

logical calculatedBorn

235

common/ccalculatedBorn/calculatedBorn

236

integer nfksprocess

237

common/c_nfksprocess/nfksprocess

238

logical cond_ij

239

C ----------

240

C BEGIN CODE

241

C ----------

242

iden=iden_values(nfksprocess)

243

glu_ij = ij_values(nfksprocess)

244

NTRY(nFKSprocess)=NTRY(nFKSprocess)+1

245

if (NTRY(nFKSprocess).lt.2) then

246

if (glu_ij.eq.0) then

247

skip(nfksprocess)=0

248

else

249

skip(nFKSprocess)=1

250

do while(nhel(glu_ij ,skip(nFKSprocess)).ne.-NHEL(GLU_IJ ,1))

251

skip(nFKSprocess)=skip(nFKSprocess)+1

252

enddo

253

skip(nFKSprocess)=skip(nFKSprocess)-1

254

endif

255

endif

256

DO JJ=1,NGRAPHS

257

amp2(jj)=0d0

258

ENDDO

259

DO I=0,NAMPSO

260

DO JJ=1,int(jamp2(0,0))

261

jamp2(jj,I)=0d0

262

ENDDO

263

ENDDO

264

if (calculatedBorn) then

265

do j=1,nexternal-1

266

if (savemom(j,1).ne.p1(0,j) .or. savemom(j,2).ne.p1(3,j)) then

267

calculatedBorn=.false.

268

write (*,*) "momenta not the same in Born"

269

stop

270

endif

271

enddo

272

endif

273

if (.not.calculatedBorn) then

274

do j=1,nexternal-1

275

savemom(j,1)=p1(0,j)

276

savemom(j,2)=p1(3,j)

277

enddo

278

do j=1,max_bhel

279

do jj=1,ngraphs

280

saveamp(jj,j)=(0d0,0d0)

281

enddo

282

enddo

283

endif

284

DO I=0,NSQAMPSO

285

ANS(1,I) = 0D0

286

ANS(2,I) = 0D0

287

ENDDO

288

hel_fac=1d0

289

DO IHEL=1,NCOMB

290

! the following lines are to avoid segfaults when glu_ij=0

291

cond_ij=skip(nfksprocess).eq.0

292

if (.not.cond_ij) cond_ij=cond_ij.or.nhel(glu_ij,ihel).EQ.NHEL(GLU_IJ,1)

293

!if (nhel(glu_ij,ihel).EQ.NHEL(GLU_IJ,1).or.skip(nfksprocess).eq.0) then

294

if (cond_ij) then

295

IF ((GOODHEL(IHEL,nFKSprocess) .OR. GOODHEL(IHEL+SKIP(nFKSprocess),nFKSprocess) .OR. NTRY(nFKSprocess) .LT. 2) ) THEN

296

297

CALL BORN(P1,NHEL(1,IHEL),IHEL,T,borns)

298

DO I=1,NSQAMPSO

299

ANS(1,I)=ANS(1,I)+T(1,I)

300

ANS(2,I)=ANS(2,I)+T(2,I)

301

ENDDO

302

if ( borns(1,0).ne.0d0 .AND. .NOT. GOODHEL(IHEL,nFKSprocess) ) then

303

GOODHEL(IHEL,nFKSprocess)=.TRUE.

304

endif

305

if ( borns(2,0).ne.0d0 .AND. .NOT. GOODHEL(IHEL+SKIP(nFKSprocess),nFKSprocess) ) then

306

GOODHEL(IHEL+SKIP(nFKSprocess),nFKSprocess)=.TRUE.

307

endif

308

ENDIF

309

ENDIF

310

ENDDO

311

DO I=1,NSQAMPSO

312

ANS(1,I)=ANS(1,I)/DBLE(IDEN)

313

ANS(2,I)=ANS(2,I)/DBLE(IDEN)

314

ANS(1,0)=ANS(1,0)+ANS(1,I)

315

ANS(2,0)=ANS(2,0)+ANS(2,I)

316

ENDDO

317

calculatedBorn=.true.

318

END

319

320

321

SUBROUTINE BORN(P,NHEL,HELL,ANS,borns)

322

323

%(info_lines)s

324

C RETURNS AMPLITUDE SQUARED SUMMED/AVG OVER COLORS

325

C FOR THE POINT WITH EXTERNAL LINES W(0:6,NEXTERNAL-1)

326

327

%(process_lines)s

328

329

IMPLICIT NONE

330

331

C CONSTANTS

332

333

INTEGER NAMPSO, NSQAMPSO

334

PARAMETER (NAMPSO=%(nAmpSplitOrders)d, NSQAMPSO=%(nSqAmpSplitOrders)d)

335

INTEGER NGRAPHS, NEIGEN

336

PARAMETER (NGRAPHS= %(ngraphs)d,NEIGEN= 1)

337

INTEGER NWAVEFUNCS, NCOLOR

338

PARAMETER (NWAVEFUNCS=%(nwavefuncs)d, NCOLOR=%(ncolor)d)

339

REAL*8 ZERO

340

PARAMETER (ZERO=0D0)

341

complex*16 imag1

342

parameter (imag1 = (0d0,1d0))

343

include "nexternal.inc"

344

include "born_nhel.inc"

345

include "coupl.inc"

346

347

C ARGUMENTS

348

349

REAL*8 P(0:3,NEXTERNAL-1),borns(2,0:NSQAMPSO)

350

INTEGER NHEL(NEXTERNAL-1), HELL

351

COMPLEX*16 ANS(2,NSQAMPSO)

352

353

C LOCAL VARIABLES

354

355

INTEGER I,J,M,N,ihel,back_hel,glu_ij

356

INTEGER IC(NEXTERNAL-1),nmo

357

parameter (nmo=nexternal-1)

358

data ic /nmo*1/

359

REAL*8 CF(NCOLOR,NCOLOR)

360

COMPLEX*16 ZTEMP, AMP(NGRAPHS), JAMP(NCOLOR,NAMPSO), W(%(wavefunctionsize)d,NWAVEFUNCS), jamph(2, ncolor,nampso)

361

COMPLEX*16 TMP_JAMP(%(nb_temp_jamp)i)

362

363

C GLOBAL VARIABLES

364

365

Double Precision amp2(%(ngraphs)d), jamp2(0:%(ncolor)d,0:nampso)

366

common/to_amps_born/ amp2, jamp2

367

double complex saveamp(ngraphs,max_bhel)

368

common/to_saveamp/saveamp

369

double precision hel_fac

370

integer get_hel,skip(%(nconfs)d)

371

common/cBorn/hel_fac,get_hel,skip

372

logical calculatedBorn

373

common/ccalculatedBorn/calculatedBorn

374

integer nfksprocess

375

common/c_nfksprocess/nfksprocess

376

integer step_hel

377

logical cond_ij

378

379

380

C FUNCTION

381

382

INTEGER SQSOINDEXB

383

384

%(ij_lines)s

385

386

C COLOR DATA

387

388

%(color_data_lines)s

389

C ----------

390

C BEGIN CODE

391

C ----------

392

glu_ij = ij_values(nfksprocess)

393

DO I = 1, NSQAMPSO

394

ANS(1,I)=0D0

395

ANS(2,I)=0D0

396

borns(1,I)=0d0

397

borns(2,I)=0d0

398

ENDDO

399

borns(1,0)=0d0

400

borns(2,0)=0d0

401

if (glu_ij.ne.0) then

402

back_hel = nhel(glu_ij)

403

if (back_hel.ne.0) then

404

step_hel=-2*back_hel

405

else

406

step_hel=1

407

endif

408

else

409

back_hel=0

410

step_hel=1

411

endif

412

DO IHEL=back_hel,-back_hel,step_hel

413

if (glu_ij.ne.0) then

414

cond_ij=IHEL.EQ.back_hel.OR.NHEL(GLU_IJ).NE.0

415

else

416

cond_ij=IHEL.EQ.back_hel

417

endif

418

IF (cond_ij) THEN

419

if (glu_ij.ne.0) then

420

if (nhel(glu_ij).ne.0) nhel(glu_ij) = ihel

421

endif

422

if (.not. calculatedBorn) then

423

%(helas_calls)s

424

do i=1,ngraphs

425

if(ihel.eq.back_hel)then

426

saveamp(i,hell)=amp(i)

427

elseif(ihel.eq.-back_hel)then

428

saveamp(i,hell+skip(nFKSprocess))=amp(i)

429

else

430

write(*,*) "ERROR #1 in born.f"

431

stop

432

endif

433

enddo

434

elseif (calculatedBorn) then

435

do i=1,ngraphs

436

if(ihel.eq.back_hel)then

437

amp(i)=saveamp(i,hell)

438

elseif(ihel.eq.-back_hel)then

439

amp(i)=saveamp(i,hell+skip(nFKSprocess))

440

else

441

write(*,*) "ERROR #1 in born.f"

442

stop

443

endif

444

enddo

445

endif

446

%(jamp_lines)s

447

DO M = 1, NAMPSO

448

DO I = 1, NCOLOR

449

ZTEMP = (0.D0,0.D0)

450

DO J = 1, NCOLOR

451

ZTEMP = ZTEMP + CF(J,I)*JAMP(J,M)

452

ENDDO

453

DO N = 1, NAMPSO

454

BORNS(2-(1+back_hel*ihel)/2,SQSOINDEXB(M,N))=BORNS(2-(1+back_hel*ihel)/2,SQSOINDEXB(M,N))+ZTEMP*DCONJG(JAMP(I,N))

455

ENDDO

456

ENDDO

457

ENDDO

458

Do I = 1, NGRAPHS

459

amp2(i)=amp2(i)+amp(i)*dconjg(amp(i))

460

Enddo

461

do J = 1,NAMPSO

462

Do I = 1, NCOLOR

463

Jamp2(i,J)=Jamp2(i,J)+Jamp(i,J)*dconjg(Jamp(i,J))

464

Jamph(2-(1+back_hel*ihel)/2,i,J)=Jamp(i,J)

465

Enddo

466

ENDDO

467

endif

468

Enddo

469

do i = 1, nsqampso

470

borns(1,0)=borns(1,0)+borns(1,i)

471

borns(2,0)=borns(2,0)+borns(2,i)

472

ans(1,i) = borns(1,i) + borns(2,i)

473

enddo

474

DO M = 1, NAMPSO

475

DO I = 1, NCOLOR

476

ZTEMP = (0.D0,0.D0)

477

DO J = 1, NCOLOR

478

ZTEMP = ZTEMP + CF(J,I)*JAMPH(2,J,M)

479

ENDDO

480

DO N = 1, NAMPSO

481

ANS(2,SQSOINDEXB(M,N))= ANS(2,SQSOINDEXB(M,N)) + ZTEMP*DCONJG(JAMPH(1,I,N))

482

ENDDO

483

ENDDO

484

ENDDO

485

if (glu_ij.ne.0) nhel(glu_ij) = back_hel

486

END

487

488

489

BLOCK DATA GOODHELS

490

INTEGER NCOMB

491

PARAMETER ( NCOMB= %(ncomb)d )

492

INTEGER THEL

493

PARAMETER (THEL=NCOMB*%(nconfs)d)

494

LOGICAL GOODHEL(NCOMB,%(nconfs)d)

495

common /c_goodhel/goodhel

496

DATA GOODHEL/THEL*.FALSE./

497

end

498

499

500

501

502

C Helper functions to deal with the split orders.

503

504

505

INTEGER FUNCTION SQSOINDEXB(AMPORDERA,AMPORDERB)

506

507

C This functions plays the role of the interference matrix. It can be hardcoded or

508

C made more elegant using hashtables if its execution speed ever becomes a relevant

509

C factor. From two split order indices of the jamps, it return the corresponding

510

C index in the squared order canonical ordering.

511

512

C CONSTANTS

513

514

implicit none

515

INTEGER NAMPSO, NSQAMPSO

516

PARAMETER (NAMPSO=%(nAmpSplitOrders)d, NSQAMPSO=%(nSqAmpSplitOrders)d)

517

INTEGER NSPLITORDERS

518

PARAMETER (NSPLITORDERS=%(nSplitOrders)d)

519

520

C ARGUMENTS

521

522

INTEGER AMPORDERA, AMPORDERB

523

524

C LOCAL VARIABLES

525

526

INTEGER I, SQORDERS(NSPLITORDERS)

527

INTEGER AMPSPLITORDERS(NAMPSO,NSPLITORDERS)

528

%(ampsplitorders)s

529

530

C FUNCTION

531

532

INTEGER SQSOINDEXB_FROM_ORDERS

533

534

C BEGIN CODE

535

536

DO I=1,NSPLITORDERS

537

SQORDERS(I)=AMPSPLITORDERS(AMPORDERA,I)+AMPSPLITORDERS(AMPORDERB,I)

538

ENDDO

539

SQSOINDEXB=SQSOINDEXB_FROM_ORDERS(SQORDERS)

540

END

541

542

543

544

INTEGER FUNCTION SQSOINDEXB_FROM_ORDERS(ORDERS)

545

546

C From a list of values for the split orders, this function returns the

547

c corresponding index in the squared orders canonical ordering.

548

549

implicit none

550

INTEGER NSQAMPSO

551

PARAMETER (NSQAMPSO=%(nSqAmpSplitOrders)d)

552

INTEGER NSPLITORDERS

553

PARAMETER (NSPLITORDERS=%(nSplitOrders)d)

554

555

C ARGUMENTS

556

557

INTEGER ORDERS(NSPLITORDERS)

558

559

C LOCAL VARIABLES

560

561

INTEGER I,J

562

INTEGER SQSPLITORDERS(NSQAMPSO,NSPLITORDERS)

563

%(sqsplitorders)s

564

565

C BEGIN CODE

566

567

DO I=1,NSQAMPSO

568

DO J=1,NSPLITORDERS

569

IF (ORDERS(J).NE.SQSPLITORDERS(I,J)) GOTO 1009

570

ENDDO

571

SQSOINDEXB_FROM_ORDERS = I

572

RETURN

573

1009 CONTINUE

574

ENDDO

575

576

WRITE(*,*) 'ERROR:: Stopping function sqsoindex_from_orders'

577

WRITE(*,*) 'Could not find squared orders ',(ORDERS(I),I=1,NSPLITORDERS)

578

STOP

579

580

END

581

582

583

584

INTEGER FUNCTION GETORDPOWFROMINDEX_B(IORDER, INDX)

585

586

C Return the power of the IORDER-th order appearing at position INDX

587

C in the split-orders output

588

589

implicit none

590

INTEGER NSQAMPSO

591

PARAMETER (NSQAMPSO=%(nSqAmpSplitOrders)d)

592

INTEGER NSPLITORDERS

593

PARAMETER (NSPLITORDERS=%(nSplitOrders)d)

594

595

C ARGUMENTS

596

597

INTEGER IORDER, INDX

598

599

C LOCAL VARIABLES

600

601

integer i

602

INTEGER SQSPLITORDERS(NSQAMPSO,NSPLITORDERS)

603

%(sqsplitorders)s

604

605

C BEGIN CODE

606

607

IF (IORDER.GT.NSPLITORDERS.OR.IORDER.LT.1) THEN

608

WRITE(*,*) "INVALID IORDER B", IORDER

609

WRITE(*,*) "SHOULD BE BETWEEN 1 AND ", NSPLITORDERS

610

STOP

611

ENDIF

612

613

IF (INDX.GT.NSQAMPSO.OR.INDX.LT.1) THEN

614

WRITE(*,*) "INVALID INDX B", INDX

615

WRITE(*,*) "SHOULD BE BETWEEN 1 AND ", NSQAMPSO

616

STOP

617

ENDIF

618

619

GETORDPOWFROMINDEX_B=SQSPLITORDERS(INDX, IORDER)

620

END

621

622

623

SUBROUTINE GET_NSQSO_B(NSQSO)

624

625

C Simple subroutine returning the number of squared split order

626

C contributions returned in ANS when calling SMATRIX_SPLITORDERS

627

628

implicit none

629

INTEGER NSQAMPSO

630

PARAMETER (NSQAMPSO=%(nSqAmpSplitOrders)d)

631

INTEGER NSQSO

632

633

NSQSO=NSQAMPSO

634

635

END

636

637

Older »