~sebastien-wertz/mg5amcnlo/standalone_cpp

1

################################################################################

2

#

3

4

#

5

# This file is a part of the MadGraph 5 project, an application which

6

# automatically generates Feynman diagrams and matrix elements for arbitrary

7

# high-energy processes in the Standard Model and beyond.

8

#

9

# It is subject to the MadGraph license which should accompany this

10

# distribution.

11

#

12

# For more information, please visit: http://madgraph.phys.ucl.ac.be

13

#

14

################################################################################

15

"""Unit test Library for testing the Creation of Helas Amplitude created from

16

the output of the Feynman Rules."""

17

from __future__ import division

18

import unittest

19

import aloha.helasamp_object as HelasObject

20

import aloha.helasamp_lib as HelasLib

21

22

23

class TestVariable(unittest.TestCase):

24

25

def setUp(self):

26

self.var1 = HelasLib.Variable(2, 'var1')

27

self.var2 = HelasLib.Variable(3, 'var2')

28

self.var3 = HelasLib.Variable(11, 'var3')

29

30

31

def testsumvarvar (self):

32

""" test the sum of two Variable Object"""

33

34

#Sum of Two Variable

35

sum = self.var1 + self.var2

36

37

#check sanity

38

self.assertEquals(sum.__class__,HelasLib.AddVariable)

39

self.assertTrue(self.var1 in sum)

40

self.assertTrue(self.var2 in sum)

41

self.assertEquals(len(sum),2)

42

43

#test prefactor, constant term treatment

44

self.assertEquals(sum.prefactor,1)

45

self.assertTrue(self.var1 in sum)

46

for term in sum:

47

if term == self.var1:

48

self.assertEqual(term.prefactor, 2)

49

self.assertFalse(term is self.var1)

50

elif term == self.var2:

51

self.assertEqual(term.prefactor, 3)

52

self.assertFalse(term is self.var2)

53

54

self.assertEquals(self.var1.prefactor, 2) #prefactor is preserve

55

self.assertEquals(self.var2.prefactor, 3)

56

57

def testrsumvarvar (self):

58

""" test the sum of two Variable Object (inverse order)"""

59

60

#Sum of Two Variable

61

sum = self.var2 + self.var1

62

#check sanity

63

self.assertEquals(sum.__class__,HelasLib.AddVariable)

64

self.assertTrue(self.var1 in sum)

65

self.assertTrue(self.var2 in sum)

66

self.assertEquals(len(sum),2)

67

68

#test prefactor, constant term treatment

69

self.assertEquals(sum.prefactor,1)

70

self.assertTrue(self.var1 in sum)

71

for term in sum:

72

if term == self.var1:

73

self.assertEqual(term.prefactor, 2)

74

self.assertFalse(term is self.var1)

75

elif term == self.var2:

76

self.assertEqual(term.prefactor, 3)

77

self.assertFalse(term is self.var2)

78

79

self.assertEquals(self.var1.prefactor,2) #prefactor is preserve

80

self.assertEquals(self.var2.prefactor,3)

81

82

def testsumvarint(self):

83

""" test the sum of one Variable with an integer"""

84

85

self.assertRaises(AttributeError,HelasLib.Variable.__add__, self.var1, 4)

86

return

87

88

def testsumvaradd(self):

89

""" test the sum of one Variable with an AddVariable"""

90

91

add = HelasLib.AddVariable()

92

add.append(self.var1)

93

add.append(self.var2)

94

95

sum = self.var3 + add

96

97

self.assertEquals(sum.__class__,HelasLib.AddVariable)

98

self.assertTrue(self.var3 in sum)

99

self.assertEquals(len(sum), 3)

100

for data in sum:

101

if data == self.var3:

102

self.assertFalse(data is self.var3)

103

else:

104

self.assertFalse(data is self.var1)

105

self.assertFalse(data is self.var2)

106

107

108

#test prefactor- constant_term

109

self.assertEquals(sum.prefactor, 1)

110

self.assertEquals(self.var1.prefactor,2)

111

112

def testsumvarmult(self):

113

""" test the sum of one Variable with an MultVariable"""

114

115

mult = HelasLib.MultVariable()

116

mult.append(self.var1)

117

mult.append(self.var2)

118

sum = self.var3 + mult

119

120

self.assertEquals(sum.__class__,HelasLib.AddVariable)

121

self.assertTrue(self.var3 in sum)

122

self.assertEquals(len(sum), 2)

123

for data in sum:

124

if data == self.var3:

125

self.assertFalse(data is self.var3)

126

self.assertEqual(data.prefactor, self.var3.prefactor)

127

128

#test prefactor- constant_term

129

self.assertEquals(sum.prefactor, 1)

130

self.assertEquals(self.var3.prefactor, 11)

131

132

def testmultvarvar(self):

133

"""product of Two Variable"""

134

135

prod = self.var1 * self.var2

136

137

#check sanity

138

self.assertEquals(prod.__class__,HelasLib.MultVariable)

139

self.assertTrue(self.var1 in prod) # presence of single term

140

self.assertTrue(self.var2 in prod) # presence of single term

141

self.assertEquals(len(prod),2)

142

143

144

self.assertEquals(prod.prefactor,6)

145

146

147

def testmultvarAdd(self):

148

"""product of Variable with an AddVariable"""

149

150

add = self.var1 + self.var2

151

prod = self.var3 * add

152

#sanity check

153

self.assertEquals(prod.__class__, HelasLib.AddVariable)

154

self.assertEquals(len(prod), 2)

155

156

#check prefactor of each term

157

for term in prod:

158

if self.var1 not in term:

159

self.assertEquals(term.prefactor, 33)

160

elif self.var2 not in term:

161

self.assertEquals(term.prefactor, 22)

162

else:

163

raise Exception('not valid term')

164

165

166

def testmultvarMult(self):

167

"""product of Variable with an MultVariable"""

168

169

var1 = HelasLib.Variable(2)

170

var2 = HelasLib.Variable(3,'y')

171

mult = HelasLib.MultVariable()

172

mult.append(var1)

173

mult.append(var2)

174

175

prod = self.var1 * mult

176

177

#Sanity

178

self.assertEquals(prod.__class__, HelasLib.MultVariable)

179

self.assertEquals(len(prod), 3)

180

181

#check prefactor

182

self.assertEquals(prod.prefactor, 12)

183

184

185

def testmultvarint(self):

186

"""product of Var with an integer"""

187

188

prod1 = self.var1 * 2

189

prod2 = 2 * self.var2

190

191

#SanityCheck

192

self.assertTrue(prod1, HelasLib.Variable)

193

self.assertTrue(prod2, HelasLib.Variable)

194

self.assertEquals(prod1, self.var1)

195

self.assertEquals(prod2, self.var2)

196

self.assertFalse(prod1 is self.var1)

197

self.assertFalse(prod2 is self.var2)

198

199

#check prefactor - constant term

200

self.assertEquals(prod1.prefactor, 4)

201

self.assertEquals(prod2.prefactor, 6)

202

203

class TestAddVariable(unittest.TestCase):

204

205

def setUp(self):

206

"""Initialize basic object"""

207

self.var1 = HelasLib.Variable(2, 'var1')

208

self.var2 = HelasLib.Variable(3, 'var2')

209

self.add1 = HelasLib.AddVariable()

210

self.add1.append(self.var1)

211

self.add1.append(self.var2)

212

213

self.var3 = HelasLib.Variable(11, 'var3')

214

self.var4 = HelasLib.Variable(4, 'var4')

215

self.add2 = HelasLib.AddVariable()

216

self.add2.append(self.var3)

217

self.add2.append(self.var4)

218

219

def testsumaddint(self):

220

"""Test the sum of an Add variable with an integer"""

221

222

add2 = self.add1 + 5

223

self.assertEqual(type(add2), HelasLib.AddVariable)

224

self.assertEqual(len(add2), 3)

225

for term in add2:

226

if term == self.var1:

227

self.assertTrue(term.prefactor, 2)

228

elif term == self.var2:

229

self.assertTrue(term.prefactor, 3)

230

else:

231

self.assertEqual(type(term), HelasLib.ConstantObject)

232

self.assertEqual(term.value, 5)

233

234

return

235

236

def testsumaddmult(self):

237

"""Test the sum of an AddVariable with a MultVariable."""

238

239

var1 = HelasLib.Variable(2)

240

var2 = HelasLib.Variable(3)

241

mult = HelasLib.MultVariable()

242

mult.append(var1)

243

mult.append(var2)

244

mult.constant_term =2

245

246

sum = self.add1 + mult

247

248

#Sanity Check

249

self.assertEquals(sum.__class__, HelasLib.AddVariable)

250

self.assertEqual(len(sum), 3)

251

self.assertTrue(mult in sum)

252

253

#check new term

254

for term in sum:

255

if term.__class__ == HelasLib.AddVariable:

256

self.assertTrue(term.prefactor, 6)

257

self.assertTrue(term.constant_term, 0)

258

259

def testsumaddvar(self):

260

"""Test the sum of an AddVariable with a Variable."""

261

262

var3 = HelasLib.Variable(11, 'var3')

263

sum = self.add1 + var3

264

self.assertEquals(sum.__class__,HelasLib.AddVariable)

265

self.assertTrue(self.var1 in sum)

266

self.assertTrue(self.var2 in sum)

267

self.assertTrue(self.var3 in sum)

268

self.assertEquals(len(sum), 3)

269

for data in sum:

270

if data == self.var1:

271

self.assertEquals(data.prefactor,2)

272

elif data == self.var2:

273

self.assertEquals(data.prefactor,3)

274

elif data == self.var3:

275

self.assertEquals(data.prefactor,11)

276

277

#test prefactor- constant_term

278

self.assertEquals(sum.prefactor, 1)

279

280

def testsumaddadd(self):

281

"""Test the sum of two add object"""

282

283

sum = self.add1 + self.add2

284

285

self.assertEquals(sum.__class__, HelasLib.AddVariable)

286

self.assertEquals(len(sum), 4)

287

288

self.assertTrue(self.var1 in sum)

289

self.assertTrue(self.var2 in sum)

290

self.assertTrue(self.var3 in sum)

291

self.assertTrue(self.var4 in sum)

292

293

for data in sum:

294

if data == self.var1:

295

self.assertEquals(data.prefactor, 2)

296

elif data == self.var2:

297

self.assertEquals(data.prefactor, 3)

298

elif data == self.var3:

299

self.assertEquals(data.prefactor, 11)

300

elif data == self.var4:

301

self.assertEquals(data.prefactor, 4)

302

#test prefactor- constant_term

303

self.assertEquals(sum.prefactor, 1)

304

305

def testmultaddint(self):

306

"""test the multiplication of an AddVariable by a Integer"""

307

308

prod1 = 3 * self.add1

309

prod2 = self.add2 * 2

310

311

self.assertEquals(prod1.__class__, HelasLib.AddVariable)

312

self.assertEquals(prod2.__class__, HelasLib.AddVariable)

313

self.assertFalse(prod1 is self.add1)

314

self.assertFalse(prod2 is self.add2)

315

self.assertEquals(len(prod1), 2)

316

self.assertEquals(len(prod2), 2)

317

318

self.assertEquals(prod1.prefactor, 1)

319

self.assertEquals(prod2.prefactor, 1)

320

321

for data in prod1:

322

if data == self.var1:

323

self.assertEquals(data.prefactor, 6)

324

elif data == self.var2:

325

self.assertEquals(data.prefactor, 9)

326

for data in prod2:

327

if data == self.var3:

328

self.assertEquals(data.prefactor, 22)

329

elif data == self.var4:

330

self.assertEquals(data.prefactor, 8)

331

332

333

def testmultadd_legacy(self):

334

""" int * AddVariable doens't change the content of AddVariable """

335

336

var1 = HelasObject.P(1,2)

337

var2 = HelasObject.P(2,2)

338

prod = var1 * var2

339

assert(prod.__class__, HelasLib.MultLorentz)

340

var3 = HelasObject.Metric(1,2)

341

342

sum = (var3 + var1 * var2)

343

new_sum = 2 * sum

344

345

self.assertEqual(new_sum.__class__, HelasLib.AddVariable)

346

self.assertEqual(len(new_sum), 2)

347

self.assertEqual(new_sum.prefactor, 1)

348

for term in new_sum:

349

self.assertEqual(term.prefactor, 2)

350

if term.__class__ == HelasObject.Metric:

351

self.assertFalse(var3 is term)

352

else:

353

self.assertEqual(term.__class__, HelasLib.MultLorentz)

354

self.assertEqual(prod, term)

355

self.assertFalse(prod is term)

356

357

def testmultaddvar(self):

358

"""Test the multiplication of an Addvariable with a Variable"""

359

360

var3 = HelasLib.Variable(11, 'var3')

361

prod = self.add1 * var3

362

#sanity check

363

self.assertEquals(prod.__class__, HelasLib.AddVariable)

364

self.assertEquals(len(prod), 2)

365

366

#check prefactor of each term

367

for term in prod:

368

if self.var1 not in term:

369

self.assertEquals(term.prefactor, 33)

370

elif self.var2 not in term:

371

self.assertEquals(term.prefactor, 22)

372

else:

373

raise Exception('not valid term')

374

375

376

def testmultaddvar_legacy(self):

377

"""Test that the legacy is preserve for Add/var multiplication"""

378

379

p1 = HelasObject.P(1,1)

380

p2 = HelasObject.P(1,2)

381

p3 = HelasObject.P(3,3)

382

383

#make (p1+p2)*p3

384

add= p1+p2

385

result= add *p3

386

387

self.assertEqual(result.__class__, HelasLib.AddVariable)

388

self.assertEqual(len(result), 2)

389

for term in result:

390

self.assertTrue(p3 in term)

391

self.assertEqual(term.__class__,HelasObject.P.mult_class)

392

393

394

395

396

def testmultaddmult(self):

397

"""Test the multiplication of an AddVariable with a MultVariable."""

398

399

var3 = HelasLib.Variable(2, 'var3')

400

var4 = HelasLib.Variable(1, 'var4')

401

prod = self.add1 * (var3 *var4)

402

403

self.assertEqual(prod.__class__, HelasLib.AddVariable)

404

self.assertEqual(len(prod), 2)

405

406

for data in prod:

407

if self.var1 in data:

408

self.assertEqual(data.__class__, HelasLib.MultVariable)

409

self.assertEqual(data.prefactor, 4)

410

else:

411

self.assertEqual(data.__class__, HelasLib.MultVariable)

412

self.assertEqual(data.prefactor, 6)

413

self.assertEqual(prod.prefactor, 1)

414

415

416

def testmultaddadd(self):

417

"""Test the multiplication between two AddVariable."""

418

419

prod = self.add1 * self.add2

420

self.assertEqual(prod.__class__, HelasLib.AddVariable)

421

self.assertEqual(len(prod), 4)

422

423

for data in prod:

424

if self.var1 in data and self.var3 in data:

425

self.assertEqual(data.__class__, HelasLib.MultVariable)

426

self.assertEqual(data.prefactor, 22)

427

elif self.var1 in data:

428

self.assertEqual(data.__class__, HelasLib.MultVariable)

429

self.assertEqual(data.prefactor, 8)

430

elif self.var2 in data and self.var3 in data:

431

self.assertEqual(data.__class__, HelasLib.MultVariable)

432

self.assertEqual(data.prefactor, 33)

433

else:

434

self.assertEqual(data.__class__, HelasLib.MultVariable)

435

self.assertEqual(data.prefactor, 12)

436

437

438

def testfactorization(self):

439

"""test the factorization"""

440

441

p1 = HelasLib.ScalarVariable('p1',[])

442

p2 = HelasLib.ScalarVariable('p2',[])

443

p3 = HelasLib.ScalarVariable('p3',[])

444

p4 = HelasLib.ScalarVariable('p4',[])

445

p5 = HelasLib.ScalarVariable('p5',[])

446

447

448

sum = p1 * p2 + p1 * p3

449

sum = sum.factorize()

450

self.assertEqual(sum.__class__,HelasLib.MultVariable)

451

self.assertEqual(len(sum),2)

452

for fact in sum:

453

if isinstance(fact, HelasLib.Variable):

454

self.assertEqual(fact, p1)

455

else:

456

self.assertEqual(fact, p3 + p2)

457

458

459

sum = p1 * p2 + p1 * p3 + 2 * p1 + 2 *p1 * p2 * p4

460

sum = sum.factorize()

461

print sum

462

#Should return p1*(p2(2*p4 + 1) + p3 + 2)

463

464

self.assertEqual(sum.__class__,HelasLib.MultVariable)

465

self.assertEqual(len(sum),2)

466

for fact in sum:

467

if isinstance(fact, HelasLib.Variable):

468

self.assertEqual(fact, p1)

469

else:

470

self.assertEqual(fact.__class__,HelasLib.AddVariable)

471

self.assertEqual(len(fact), 2)

472

for term in fact:

473

if isinstance(term, HelasLib.AddVariable):

474

self.assertEqual(term[0], p3)

475

self.assertEqual(term[1], HelasLib.ConstantObject(2))

476

else:

477

self.assertEqual(term.__class__, HelasLib.MultVariable)

478

self.assertTrue(p2 in term)

479

self.assertTrue(len(term),2)

480

for data in term:

481

if data == p2:

482

pass

483

else:

484

self.assertEqual(data.__class__, HelasLib.AddVariable)

485

self.assertTrue(p4 in data)

486

self.assertTrue(HelasLib.ConstantObject(1) in data)

487

for term2 in data:

488

if term2 == p4:

489

self.assertEqual(term2.prefactor,2)

490

else:

491

print term2, term2.__class__

492

self.assertEqual(term2, \

493

HelasLib.ConstantObject(1))

494

495

496

s3 = HelasLib.ScalarVariable('s3',[])

497

s2 = HelasLib.ScalarVariable('s2',[])

498

p1 = HelasLib.ScalarVariable('p1',[])

499

om1 = HelasLib.ScalarVariable('om1',[])

500

sum = 2/3 * s3 * s2 - 4/3 * p1 * p1 * s3 * s2 * om1 + \

501

2/3 * p1 * p1 * p1 * p1 * om1 *om1

502

print sum

503

sum = sum.factorize()

504

print sum

505

506

507

508

509

510

511

512

513

class TestMultVariable(unittest.TestCase):

514

515

def setUp(self):

516

self.var1 = HelasLib.Variable(2, 'var1')

517

self.var2 = HelasLib.Variable(3, 'var2')

518

self.var3 = HelasLib.Variable(4, 'var3')

519

self.var4 = HelasLib.Variable(5, 'var4')

520

521

self.mult1 = self.var1 * self.var2

522

self.mult2 = self.var3 * self.var4

523

524

def testequality(self):

525

"""test the definition of Equality"""

526

527

#test with mult obj

528

529

self.assertNotEqual(self.mult1, self.mult2)

530

531

#test with other type of obj

532

self.assertNotEqual(self.mult1, 32)

533

self.assertNotEqual(self.mult1, self.var1)

534

self.assertNotEqual(self.mult1, self.var1 + self.var2)

535

536

def testsummultmul(self):

537

"""Test the sum of two MultVariable"""

538

539

sum = self.mult1 + self.mult2

540

self.assertEqual(sum.__class__, HelasLib.AddVariable)

541

self.assertEqual(len(sum),2)

542

self.assertEqual(sum.prefactor, 1)

543

544

for term in sum:

545

if self.var1 in term:

546

self.assertEqual(term.prefactor, 6)

547

self.assertFalse(term is self.mult1)

548

else:

549

self.assertEqual(term.prefactor, 20)

550

self.assertFalse(term is self.mult2)

551

552

sum = self.mult1 - self.mult1

553

sum = sum.simplify()

554

self.assertEqual(sum.__class__, HelasLib.ConstantObject)

555

self.assertEqual(len(sum),0)

556

self.assertEqual(sum.prefactor, 1)

557

558

def testdealingwithpower1(self):

559

"""Check that the power is correctly set in a product"""

560

561

p1 = HelasLib.ScalarVariable('p1', [])

562

p2 = HelasLib.ScalarVariable('p2', [])

563

564

prod = p1 * p1

565

self.assertEqual(prod.__class__, HelasLib.MultVariable)

566

prod = prod.simplify()

567

self.assertEqual(prod.__class__, HelasLib.ScalarVariable)

568

self.assertEqual(prod.power, 2)

569

self.assertEqual(p1.power, 1)

570

571

prod *= p1

572

prod = prod.simplify()

573

self.assertEqual(prod.__class__, HelasLib.ScalarVariable)

574

self.assertEqual(prod.power, 3)

575

self.assertEqual(p1.power, 1)

576

577

prod *= p2

578

prod.simplify()

579

self.assertEqual(prod.__class__, HelasLib.MultVariable)

580

self.assertEqual(prod[0].power, 3)

581

self.assertEqual(prod[1].power, 1)

582

self.assertEqual(p1.power, 1)

583

self.assertEqual(p2.power, 1)

584

585

prod *= p1

586

prod.simplify()

587

self.assertEqual(prod.__class__, HelasLib.MultVariable)

588

self.assertEqual(prod[0].power, 4)

589

self.assertEqual(prod[1].power, 1)

590

self.assertEqual(p1.power, 1)

591

self.assertEqual(p2.power, 1)

592

593

def testdealingwithpower2(self):

594

"""Check that the power is correctly set in a product"""

595

596

p1 = HelasLib.ScalarVariable('p1', [])

597

p2 = HelasLib.ScalarVariable('p2', [])

598

p3 = HelasLib.ScalarVariable('p3', [])

599

p4 = HelasLib.ScalarVariable('p2', [])

600

p5 = HelasLib.ScalarVariable('p5', [])

601

sum1 = p1 + p2

602

sum2 = p4 + p3

603

604

prod = p3 * sum2 * sum1

605

self.assertEqual(prod.__class__, HelasLib.AddVariable)

606

for term in sum1 + sum2:

607

self.assertEqual(term.power, 1)

608

609

obj1 = 0

610

for term in prod:

611

if p2 == term:

612

self.assertEqual(term.power, 2)

613

elif p1 in term and p2 in term and p3 in term:

614

self.assertEqual(term[0].power, 1)

615

self.assertEqual(term[1].power, 1)

616

self.assertEqual(term[2].power, 1)

617

if not obj1:

618

obj1= term[1]

619

else:

620

self.assertFalse(obj1 is term[1])

621

elif p2 in term and p3 in term:

622

self.assertEqual(term[0].power+term[1].power, 3)

623

if not obj1:

624

obj1= term[1]

625

else:

626

self.assertFalse(obj1 is term[1])

627

628

629

630

631

632

def test_obj_are_not_modified(self):

633

"""Check that a sum-product-... doesn't change part of the objects"""

634

635

sum = self.mult1 + self.mult2

636

for term in sum:

637

self.assertFalse(term is self.mult1)

638

self.assertFalse(term is self.mult2)

639

640

641

sum2 = sum - (self.mult1 + self.mult2)

642

#for term in sum:

643

# for term2 in sum2:

644

# self.assertFalse(term is term2)

645

646

sum2 = sum2.simplify()

647

648

#check that sum2 is zero

649

self.assertEqual(len(sum2), 0)

650

self.assertEqual(sum2.__class__, HelasLib.ConstantObject)

651

self.assertEqual(sum2, 0)

652

653

#check that the sum is not modify in this game

654

self.assertEqual(sum.__class__, HelasLib.AddVariable)

655

self.assertEqual(len(sum), 2)

656

self.assertEqual(sum.prefactor, 1)

657

658

for data in sum:

659

self.assertEqual(len(data), 2)

660

if self.var1 in data:

661

self.assertEqual(data.prefactor, 6)

662

self.assertTrue(self.var2 in data)

663

else:

664

self.assertEqual(data.prefactor, 20)

665

self.assertTrue(self.var3 in data)

666

self.assertTrue(self.var4 in data)

667

668

def testsummultint(self):

669

"""Test the sum of a MultVariable object with a number"""

670

671

self.assertRaises(AttributeError, HelasLib.MultVariable.__add__, self.mult1, 2)

672

return

673

674

def testsummultadd(self):

675

"""Test the sum of an MultVariable with a AddVariable."""

676

677

var1 = HelasLib.Variable(2,'xxx')

678

var2 = HelasLib.Variable(3,'yyy')

679

add = var1 + var2

680

681

sum = self.mult2 + add

682

#Sanity Check

683

self.assertEquals(sum.__class__, HelasLib.AddVariable)

684

self.assertEqual(len(sum), 3)

685

self.assertTrue(var1 in sum)

686

self.assertTrue(var2 in sum)

687

688

#check new term

689

for term in sum:

690

if term.__class__ == HelasLib.MultVariable:

691

self.assertEqual(term.prefactor, 20)

692

self.assertTrue(self.var3 in term)

693

self.assertTrue(self.var4 in term)

694

elif term == var1:

695

self.assertEqual(term.prefactor, 2)

696

elif term == var2:

697

self.assertEqual(term.prefactor, 3)

698

699

self.assertEqual(sum.prefactor, 1)

700

701

def testsummulvar(self):

702

"""Test the sum of a MultVariable with a Variable"""

703

704

705

var = HelasLib.Variable(3,'xxx')

706

sum = self.mult2 + var

707

708

self.assertEquals(sum.__class__,HelasLib.AddVariable)

709

self.assertTrue(var in sum)

710

self.assertEquals(len(sum), 2)

711

for term in sum:

712

if term == var:

713

self.assertEquals(term.prefactor, 3)

714

self.assertFalse(term is var)

715

else:

716

self.assertTrue(self.var3 in term)

717

self.assertTrue(self.var4 in term)

718

self.assertEqual(term.prefactor, 20)

719

720

#test prefactor- constant_term

721

self.assertEquals(sum.prefactor, 1)

722

self.assertEquals(var.prefactor, 3)

723

self.assertEquals(self.mult2.prefactor, 20)

724

725

def testmultmultint(self):

726

"""Test the multiplication of an MultVariable with an integer"""

727

728

prod1 = self.mult1 * 2

729

730

self.assertEqual(prod1.__class__, HelasLib.MultVariable)

731

self.assertEqual(len(prod1), 2)

732

self.assertFalse(prod1 is self.mult1)

733

self.assertEqual(prod1.prefactor, 12)

734

for fact in prod1:

735

if fact == self.var1:

736

self.assertEqual(fact.prefactor, 1)

737

if fact == self.var2:

738

self.assertEqual(fact.prefactor, 1)

739

740

prod2 = 2 * self.mult1

741

742

self.assertEqual(prod2.__class__, HelasLib.MultVariable)

743

self.assertEqual(len(prod2), 2)

744

self.assertEqual(prod2.prefactor, 12)

745

for fact in prod1:

746

if fact == self.var1:

747

self.assertEqual(fact.prefactor, 1)

748

if fact == self.var2:

749

self.assertEqual(fact.prefactor, 1)

750

751

752

def testmultmultmult(self):

753

"""test the multiplication of two MultVariable"""

754

755

prod1 = self.mult1 * self.mult2

756

self.assertEqual(prod1.__class__, HelasLib.MultVariable)

757

self.assertEqual(len(prod1), 4)

758

self.assertTrue(self.var1 in prod1)

759

self.assertTrue(self.var2 in prod1)

760

self.assertTrue(self.var3 in prod1)

761

self.assertTrue(self.var4 in prod1)

762

self.assertEqual(prod1.prefactor, 120)

763

764

for fact in prod1:

765

self.assertEqual(fact.prefactor, 1)

766

767

768

769

class TestFracVariable(unittest.TestCase):

770

""" Class to test the Operation linked to a FracVariable """

771

772

def setUp(self):

773

""" some building block """

774

775

self.p1 = HelasObject.P(1,2)

776

self.p2 = HelasObject.P(1,3)

777

self.mass1 = HelasObject.Mass(2)

778

self.mass2 = HelasObject.Mass(3)

779

self.frac1 = HelasLib.FracVariable(self.p1, self.mass1)

780

self.frac2 = HelasLib.FracVariable(self.p2, self.mass2)

781

782

def testcreation(self):

783

""" test if we can create FracVariable Object with division"""

784

785

#

786

# First check the creation at Lorentz Object

787

#

788

frac1= self.p1 / self.mass1

789

self.assertEqual(frac1.__class__, HelasLib.FracVariable)

790

self.assertEqual(frac1, self.frac1)

791

# Verif that the object are different

792

self.assertFalse(frac1.numerator is self.p1)

793

self.assertFalse(frac1.denominator is self.mass1)

794

795

sum = self.p1 +self.p2

796

frac2 = sum / self.mass1

797

self.assertEqual(frac2.__class__, HelasLib.FracVariable)

798

self.assertEqual(frac2.numerator, sum)

799

self.assertEqual(frac2.denominator, self.mass1)

800

# Verif that the object are different

801

self.assertFalse(frac2.numerator is sum)

802

self.assertFalse(frac2.denominator is self.mass1)

803

804

prod = self.p1 * self.p2

805

frac3 = prod / self.mass1

806

self.assertEqual(frac3.__class__, HelasLib.FracVariable)

807

self.assertEqual(frac3.numerator, prod)

808

self.assertEqual(frac3.denominator, self.mass1)

809

# Verif that the object are different

810

self.assertFalse(frac3.numerator is prod)

811

self.assertFalse(frac3.denominator is self.mass1)

812

813

frac4 = 2 / self.mass1

814

self.assertEqual(frac4.__class__, HelasLib.FracVariable)

815

self.assertTrue(isinstance(frac4.numerator, int))

816

self.assertEqual(frac4.numerator, 2)

817

self.assertTrue(isinstance(frac4.denominator,HelasLib.Variable))

818

self.assertEqual(frac4.denominator, self.mass1)

819

self.assertFalse(frac4.denominator is self.mass1)

820

821

sum = (self.mass1 + self.mass2)

822

frac4 = 2 / sum

823

self.assertEqual(frac4.__class__, HelasLib.FracVariable)

824

self.assertTrue(isinstance(frac4.numerator, int))

825

self.assertEqual(frac4.numerator, 2)

826

self.assertTrue(isinstance(frac4.denominator,HelasLib.AddVariable))

827

self.assertEqual(frac4.denominator, sum)

828

self.assertFalse(frac4.denominator is sum)

829

830

prod = self.mass1 * self.mass2

831

frac4 = 2 / prod

832

self.assertEqual(frac4.__class__, HelasLib.FracVariable)

833

self.assertTrue(isinstance(frac4.numerator, int))

834

self.assertEqual(frac4.numerator, 2)

835

self.assertTrue(isinstance(frac4.denominator,HelasLib.MultVariable))

836

self.assertTrue(isinstance(frac4.denominator,HelasLib.MultLorentz))

837

self.assertEqual(frac4.denominator, prod)

838

self.assertFalse(frac4.denominator is prod)

839

840

841

def testmultiplacation(self):

842

"""Frac Variable can be multiply by any object"""

843

844

#product with Variable

845

prod1 = self.frac1 * self.p1

846

self.assertEqual(prod1.__class__, HelasLib.FracVariable)

847

self.assertEqual(prod1.numerator, self.p1 * self.p1)

848

self.assertEqual(prod1.denominator, self.mass1)

849

850

prod2 = self.p1 * self.frac1

851

self.assertEqual(prod2.__class__, HelasLib.FracVariable)

852

self.assertEqual(prod2.numerator, self.p1 * self.p1)

853

self.assertEqual(prod2.denominator, self.mass1)

854

855

#product with MultVariable

856

prod = self.p1 * self.p2

857

prod2 = prod * self.frac1

858

self.assertEqual(prod2.__class__, HelasLib.FracVariable)

859

self.assertEqual(prod2.numerator, self.p1 * self.p2 * self.p1)

860

self.assertEqual(prod2.denominator, self.mass1)

861

862

prod3 = self.frac1 * prod

863

self.assertEqual(prod3.__class__, HelasLib.FracVariable)

864

self.assertEqual(prod3.numerator, self.p1 * self.p2 * self.p1)

865

self.assertEqual(prod3.denominator, self.mass1)

866

867

# Product with SumVariable

868

sum = self.p1 +self.p2

869

prod2 = sum * self.frac1

870

self.assertEqual(prod2.__class__, HelasLib.FracVariable)

871

self.assertEqual(prod2.numerator, sum * self.p1)

872

self.assertEqual(prod2.denominator, self.mass1)

873

874

prod3 = self.frac1 * sum

875

self.assertEqual(prod3.__class__, HelasLib.FracVariable)

876

self.assertEqual(prod3.numerator, sum * self.p1)

877

self.assertEqual(prod3.denominator, self.mass1)

878

879

880

# Product with FracVariable

881

prod = self.frac1 * self.frac2

882

self.assertEqual(prod.__class__, HelasLib.FracVariable)

883

self.assertEqual(prod.numerator.__class__, HelasLib.MultLorentz)

884

self.assertEqual(prod.numerator, self.p2 * self.p1)

885

self.assertEqual(prod.denominator, self.mass1 * self.mass2)

886

887

prod3 = self.frac2 * self.frac1

888

self.assertEqual(prod3.__class__, HelasLib.FracVariable)

889

self.assertEqual(prod3.numerator, self.p2 * self.p1)

890

self.assertEqual(prod3.denominator, self.mass1 * self.mass2)

891

892

893

def testdivision(self):

894

""" Test division with a FracVariable """

895

896

#divide with Variable

897

prod1 = self.frac1 / self.p1

898

self.assertEqual(prod1.__class__, HelasLib.FracVariable)

899

self.assertEqual(prod1.numerator, self.p1)

900

self.assertEqual(prod1.denominator, self.p1 * self.mass1)

901

902

#divide with a MultVariable

903

prod= self.p1 * self.p2

904

prod3 = self.frac1 / prod

905

self.assertEqual(prod3.__class__, HelasLib.FracVariable)

906

self.assertEqual(prod3.numerator, self.p1)

907

self.assertEqual(prod3.denominator, self.mass1 * self.p1 * self.p2)

908

909

# divide with AddVariable

910

sum = self.p1 +self.p2

911

prod2 = self.frac1 / sum

912

self.assertEqual(prod2.__class__, HelasLib.FracVariable)

913

self.assertEqual(prod2.numerator, self.p1)

914

self.assertEqual(prod2.denominator, sum * self.mass1)

915

916

917

918

919

class testLorentzObject(unittest.TestCase):

920

""" Class to test the Operation linked to a Lorentz Object"""

921

922

def setUp(self):

923

924

self.p1= HelasObject.P(1,2)

925

self.p2= HelasObject.P(1,3)

926

self.p3= HelasObject.P(2,2)

927

self.p4= HelasObject.P(2,3)

928

929

def testbasicoperation(self):

930

"""Test the sum/product run correctly on High level object.

931

Those test will be basic since everything should derive from particle

932

"""

933

934

new = self.p1 * self.p2 + self.p3 * self.p4

935

self.assertEqual(new.__class__, HelasLib.AddVariable)

936

self.assertEqual(len(new), 2)

937

938

new2 = HelasObject.Gamma(1,2,3) * HelasObject.P(1,2)

939

940

self.assertEqual(new2.__class__, HelasLib.MultLorentz)

941

self.assertEqual(len(new2), 2)

942

943

new2 += HelasObject.Gamma(1,2,3) * HelasObject.P(1,3)

944

self.assertEqual(new2.__class__, HelasLib.AddVariable)

945

self.assertEqual(len(new2), 2)

946

self.assertNotEqual(new, new2)

947

948

def test_equality(self):

949

"""test the equality of Lorentz Object"""

950

951

self.assertEqual(self.p1,self.p1)

952

self.assertNotEqual(self.p1,self.p2)

953

self.assertNotEqual(self.p1,self.p3)

954

self.assertNotEqual(self.p1,self.p4)

955

self.assertEqual(self.p1, HelasObject.P(1,2))

956

957

self.assertNotEqual(self.p1, HelasObject.Gamma(1,2,3))

958

959

new = HelasObject.Gamma(1,2,3) * HelasObject.P(1,2)

960

new2 = HelasObject.Gamma(1,2,3) * HelasObject.P(1,2)

961

self.assertEqual(new, new2)

962

963

#Check that sum indices are not consider for equality

964

new3 = HelasObject.Gamma(3,2,3) * HelasObject.P(3,2)

965

self.assertEqual(new, new3)

966

967

new4 = HelasObject.P(3,2) * HelasObject.Gamma(3,2,3)

968

self.assertEqual(new, new4)

969

self.assertEqual(new3, new4)

970

971

new5 = HelasObject.P(4,2) * HelasObject.Gamma(4,2,3)

972

self.assertEqual(new, new5)

973

self.assertEqual(new3, new5)

974

self.assertEqual(new4, new5)

975

976

new6 = HelasObject.P(3,2) * HelasObject.Gamma(3,3,2)

977

self.assertNotEqual(new, new6)

978

979

new7 = HelasObject.P(3,4) * HelasObject.Gamma(3,2,3)

980

self.assertNotEqual(new, new7)

981

982

#Test contraction on spin

983

new = HelasObject.Gamma(3,3,2) * HelasObject.Gamma(2,2,4) * \

984

HelasObject.P(3,3) * HelasObject.P(2,4)

985

new2 = HelasObject.Gamma(3,3,2) * HelasObject.Gamma(2,2,4) * \

986

HelasObject.P(3,4) * HelasObject.P(2,3)

987

self.assertNotEqual(new,new2)

988

989

new3 = HelasObject.P(1,3) * HelasObject.Gamma(1,3,1) * HelasObject.P(4,4) * \

990

HelasObject.Gamma(4,1,4)

991

self.assertEqual(new, new3)

992

self.assertNotEqual(new2, new3)

993

994

new4 = HelasObject.P(1,3) * HelasObject.Gamma(1,3,2) * HelasObject.P(4,4) * \

995

HelasObject.Gamma(4,1,4)

996

self.assertNotEqual(new,new4)

997

998

def testexpand(self):

999

"""Test if the expansion from HighLevel to LowLevel works correctly"""

1000

1001

#expand a single object

1002

obj = HelasObject.P(1,2)

1003

low_level = obj.expand()

1004

1005

keys= low_level.keys()

1006

keys.sort()

1007

self.assertEqual(keys, [(0,),(1,),(2,),(3,)])

1008

self.assertEqual(low_level[(0,)], HelasLib.ScalarVariable('P2_0',[2]))

1009

self.assertEqual(low_level[(1,)], HelasLib.ScalarVariable('P2_1',[2]))

1010

self.assertEqual(low_level[(2,)], HelasLib.ScalarVariable('P2_2',[2]))

1011

self.assertEqual(low_level[(3,)], HelasLib.ScalarVariable('P2_3',[2]))

1012

1013

1014

#expand a product

1015

obj = HelasObject.P(1,2) * HelasObject.P(2,3)

1016

low_level = obj.expand()

1017

1018

for ind in low_level.listindices():

1019

self.assertEqual(low_level.get_rep(ind), \

1020

HelasLib.ScalarVariable('P2_%s' % ind[1]) * \

1021

HelasLib.ScalarVariable('P3_%s' % ind[0]))

1022

1023

#expand a sum

1024

obj = HelasObject.P(1,2) + HelasObject.P(1,3)

1025

low_level = obj.expand()

1026

1027

for ind in low_level.listindices():

1028

self.assertEqual(low_level.get_rep(ind), \

1029

HelasLib.ScalarVariable('P2_%s' % ind[0]) + \

1030

HelasLib.ScalarVariable('P3_%s' % ind[0]))

1031

1032

#expand zero

1033

obj = HelasObject.P(1,2) - HelasObject.P(1,2)

1034

obj = obj.simplify()

1035

low_level = obj.expand()

1036

pass_in_check = 0

1037

for ind in low_level.listindices():

1038

pass_in_check += 1

1039

self.assertEqual(low_level.get_rep(ind), 0)

1040

self.assertEqual(pass_in_check, 1)

1041

1042

#expand zero without first simplification

1043

obj = HelasObject.P(1,2) - HelasObject.P(1,2)

1044

low_level = obj.expand().simplify()

1045

pass_in_check = 0

1046

for ind in low_level.listindices():

1047

pass_in_check += 1

1048

self.assertEqual(low_level.get_rep(ind), 0)

1049

self.assertEqual(pass_in_check, 4)

1050

1051

#expand standard frac variable

1052

obj = HelasObject.P(1,2) / HelasObject.P(1,2)

1053

obj = obj.expand()

1054

result = {(0,): HelasLib.ScalarVariable('P2_0',[2]), \

1055

(1,): HelasLib.ScalarVariable('P2_1',[2]), \

1056

(2,): HelasLib.ScalarVariable('P2_2',[2]), \

1057

(3,): HelasLib.ScalarVariable('P2_3',[2])}

1058

for i in range(3):

1059

self.assertEqual(result[tuple([i])], obj.numerator[tuple([i])])

1060

self.assertEqual(result[tuple([i])], obj.denominator[tuple([i])])

1061

1062

1063

#expand standard frac variable with number numerator

1064

obj = 1 / HelasObject.P(1,2)

1065

obj = obj.expand()

1066

self.assertEqual(obj.numerator, 1)

1067

for i in range(3):

1068

self.assertEqual(result[tuple([i])], obj.denominator[tuple([i])])

1069

1070

# Check for the prefactor

1071

obj = 36 * HelasObject.P(1,2)

1072

obj = obj.expand()

1073

for ind in obj.listindices():

1074

expression = obj.get_rep(ind)

1075

self.assertEqual(expression.prefactor, 36)

1076

1077

# Check for the prefactor

1078

obj = 36 * HelasObject.P(1,2) * HelasObject.P(2,2)

1079

obj = obj.expand()

1080

for ind in obj.listindices():

1081

expression = obj.get_rep(ind)

1082

self.assertEqual(expression.prefactor, 36)

1083

1084

1085

def testTraceofObject(self):

1086

"""Check that we can output the trace of an object"""

1087

1088

obj = HelasObject.Gamma(1,1,1)

1089

obj.expand()

1090

obj.simplify()

1091

1092

def testscalarmanipulation(self):

1093

"""Deal correctly with Scalar type of LorentzObject"""

1094

1095

obj= HelasObject.Mass(3)

1096

obj = obj.simplify()

1097

low_level = obj.expand()

1098

for ind in low_level.listindices():

1099

self.assertEqual(low_level.get_rep(ind).__class__, HelasLib.ScalarVariable)

1100

self.assertEqual(low_level.get_rep(ind), HelasLib.ScalarVariable('M3',[3]))

1101

1102

obj= HelasObject.Mass(3) * HelasObject.P(1,2)

1103

obj = obj.simplify()

1104

low_level = obj.expand()

1105

self.assertEqual(low_level.__class__, HelasLib.LorentzObjectRepresentation)

1106

for ind in low_level.listindices():

1107

self.assertEqual(low_level.get_rep(ind).__class__, HelasLib.MultVariable)

1108

self.assertEqual(low_level.get_rep(ind), HelasLib.ScalarVariable('M3',[3])

1109

* HelasLib.ScalarVariable('P2_%s' % ind[0],[0]))

1110

1111

1112

class TestLorentzObjectRepresentation(unittest.TestCase):

1113

"""Class to test the operation in the LorentzObjectRepresentation"""

1114

1115

#for lorentz manipulation

1116

p1nu = HelasObject.P(1,1)

1117

p1nu = p1nu.expand()

1118

p1mu = HelasObject.P(2,1)

1119

p1mu = p1mu.expand()

1120

p2nu = HelasObject.P(1,2)

1121

p2nu = p2nu.expand()

1122

p2mu = HelasObject.P(2,2)

1123

p2mu = p2mu.expand()

1124

1125

#for lorentz - spin manipulation

1126

gamma_nu_ij = HelasObject.Gamma(1,1,2)

1127

gamma_nu_ij = gamma_nu_ij.expand()

1128

gamma_nu_ji = HelasObject.Gamma(1,2,1)

1129

gamma_nu_ji = gamma_nu_ji.expand()

1130

gamma_mu_ij = HelasObject.Gamma(2,1,2)

1131

gamma_mu_ij = gamma_mu_ij.expand()

1132

gamma_nu_jk = HelasObject.Gamma(1,2,3)

1133

gamma_nu_jk = gamma_nu_jk.expand()

1134

gamma_mu_jk = HelasObject.Gamma(2,2,3)

1135

gamma_mu_jk = gamma_mu_jk.expand()

1136

gamma_nu_kl = HelasObject.Gamma(1,3,4)

1137

gamma_nu_kl = gamma_nu_kl.expand()

1138

gamma_mu_kl = HelasObject.Gamma(2,3,4)

1139

gamma_mu_kl = gamma_mu_kl.expand()

1140

gamma_mu_ki = HelasObject.Gamma(2,3,1)

1141

gamma_mu_ki = gamma_mu_ki.expand()

1142

1143

def testlistindices(self):

1144

"""test that we return the correct list of indices"""

1145

1146

#only lorentz indices

1147

test1 = HelasLib.LorentzObjectRepresentation([],[1,2],[],[])

1148

1149

already_use=[]

1150

for ind in test1.listindices():

1151

self.assertFalse(ind in already_use, '%s appear two times' % ind)

1152

already_use.append(list(ind))

1153

for value in ind:

1154

self.assertTrue(value >= 0)

1155

self.assertTrue(value < 4)

1156

self.assertEqual(len(already_use), 16)

1157

1158

#only spin indices

1159

test1 = HelasLib.LorentzObjectRepresentation([],[],[1,2,3],[])

1160

1161

already_use=[]

1162

for ind in test1.listindices():

1163

self.assertFalse(ind in already_use, '%s appear two times' % ind)

1164

already_use.append(list(ind))

1165

for value in ind:

1166

self.assertTrue(value >= 0)

1167

self.assertTrue(value < 4)

1168

self.assertEqual(len(already_use), 64)

1169

1170

#mix of indices

1171

test1 = HelasLib.LorentzObjectRepresentation([],[1],[1,2,3],[])

1172

1173

already_use=[]

1174

for ind in test1.listindices():

1175

self.assertFalse(ind in already_use, '%s appear two times' % ind)

1176

already_use.append(list(ind))

1177

for value in ind:

1178

self.assertTrue(value >= 0)

1179

self.assertTrue(value < 4)

1180

self.assertEqual(len(already_use), 256)

1181

1182

#only one indice

1183

test1 = HelasLib.LorentzObjectRepresentation([],[1],[],[])

1184

1185

already_use=[]

1186

for ind in test1.listindices():

1187

self.assertFalse(ind in already_use, '%s appear two times' % ind)

1188

already_use.append(list(ind))

1189

for value in ind:

1190

self.assertTrue(value >= 0)

1191

self.assertTrue(value < 4)

1192

self.assertEqual(len(already_use), 4)

1193

1194

#no indices

1195

test1 = HelasLib.LorentzObjectRepresentation(38,[],[],[])

1196

1197

already_use=[]

1198

for ind in test1.listindices():

1199

self.assertEqual(ind,[0])

1200

already_use.append(list(ind))

1201

self.assertEqual(len(already_use), 1)

1202

1203

def testgetrepresentation(self):

1204

"""Check the way to find representation"""

1205

1206

data={(0,0):1, (0,1):2, (0,2):3, (0,3):4,

1207

(1,0):2, (1,1):4, (1,2):6, (1,3):8,

1208

(2,0):3, (2,1):6, (2,2):9, (2,3):12,

1209

(3,0):4, (3,1):8, (3,2):12, (3,3):16

1210

}

1211

1212

repr1 = HelasLib.LorentzObjectRepresentation(data, [1], [1], [])

1213

repr2 = HelasLib.LorentzObjectRepresentation(data, [1, 2], [], [])

1214

repr3 = HelasLib.LorentzObjectRepresentation(data, [], [1, 2], [])

1215

1216

for ind in repr1.listindices():

1217

self.assertEquals(repr1.get_rep(ind), (ind[0]+1)*(ind[1]+1))

1218

self.assertEquals(repr2.get_rep(ind), (ind[0]+1)*(ind[1]+1))

1219

self.assertEquals(repr3.get_rep(ind), (ind[0]+1)*(ind[1]+1))

1220

1221

1222

#check the dealing with scalar

1223

repr4 = HelasLib.LorentzObjectRepresentation(49, [], [], [])

1224

for ind in repr4.listindices():

1225

self.assertEquals(repr4.get_rep(ind), 49)

1226

1227

def testsetrepresentation(self):

1228

"""Check the way to set a representation"""

1229

1230

goal=[[1, 2, 3 , 4], [2, 4, 6, 8], [3, 6, 9, 12], [4, 8, 12, 16]]

1231

1232

repr1 = HelasLib.LorentzObjectRepresentation([], [1], [1], [])

1233

repr2 = HelasLib.LorentzObjectRepresentation([], [1, 2], [], [])

1234

repr3 = HelasLib.LorentzObjectRepresentation([], [], [1, 2], [])

1235

1236

for ind in repr1.listindices():

1237

repr1.set_rep(ind, (ind[0]+1)*(ind[1]+1))

1238

repr2.set_rep(ind, (ind[0]+1)*(ind[1]+1))

1239

repr3.set_rep(ind, (ind[0]+1)*(ind[1]+1))

1240

1241

for ind in repr1.listindices():

1242

self.assertEquals(repr1.get_rep(ind), (ind[0]+1)*(ind[1]+1))

1243

self.assertEquals(repr2.get_rep(ind), (ind[0]+1)*(ind[1]+1))

1244

self.assertEquals(repr3.get_rep(ind), (ind[0]+1)*(ind[1]+1))

1245

1246

for ind in repr1.listindices():

1247

self.assertEquals(repr1.get_rep(ind), goal[ind[0]][ind[1]])

1248

self.assertEquals(repr2.get_rep(ind), goal[ind[0]][ind[1]])

1249

self.assertEquals(repr3.get_rep(ind), goal[ind[0]][ind[1]])

1250

1251

self.assertEquals(repr1.get_rep(ind), (ind[0]+1)*(ind[1]+1))

1252

self.assertEquals(repr2.get_rep(ind), (ind[0]+1)*(ind[1]+1))

1253

self.assertEquals(repr3.get_rep(ind), (ind[0]+1)*(ind[1]+1))

1254

1255

1256

def testtensorialproductlorentz(self):

1257

"""Test that two object have correct product"""

1258

1259

product = self.p1nu * self.p2mu

1260

1261

#check global

1262

self.assertTrue(isinstance(product, HelasLib.LorentzObjectRepresentation))

1263

self.assertEquals(product.lorentz_ind, [1,2])

1264

self.assertEqual(product.spin_ind, [])

1265

self.assertEqual(product.tag, set(['P1','P2']))

1266

1267

#check the representation

1268

for ind in product.listindices():

1269

rep = product.get_rep(ind)

1270

self.assertEqual(rep.__class__, HelasLib.MultVariable)

1271

self.assertEqual(len(rep), 2)

1272

for data in rep:

1273

if not( data.variable == 'P1_%s' % ind[0] or data.variable == \

1274

'P2_%s' % ind[1]):

1275

raise Exception('invalid product')

1276

self.assertNotEqual(rep[0].variable, rep[1].variable)

1277

1278

1279

def testtensorialproductspin(self):

1280

"""test the product in spin indices"""

1281

1282

product1 = self.gamma_nu_ij * self.gamma_mu_kl

1283

1284

#check global

1285

self.assertTrue(isinstance(product1, HelasLib.LorentzObjectRepresentation))

1286

self.assertEquals(product1.lorentz_ind, [1,2])

1287

self.assertEqual(product1.spin_ind, [1,2,3,4])

1288

self.assertEqual(product1.tag, set([]))

1289

1290

#check the representation

1291

for ind in product1.listindices():

1292

rep = product1.get_rep(ind)

1293

1294

fact1 = self.gamma_nu_ij.get_rep([ind[0],ind[2],ind[3]])

1295

fact2 = self.gamma_mu_kl.get_rep([ind[1],ind[4],ind[5]])

1296

self.assertEqual(rep, fact1 * fact2)

1297

1298

1299

#Check with a lorentz contraction

1300

product2 = self.gamma_nu_ij * self.gamma_nu_kl

1301

1302

#check global

1303

self.assertTrue(isinstance(product2, HelasLib.LorentzObjectRepresentation))

1304

self.assertEquals(product2.lorentz_ind, [])

1305

self.assertEqual(product2.spin_ind, [1,2,3,4])

1306

self.assertEqual(product2.tag, set([]))

1307

1308

#check the representation

1309

for ind in product2.listindices():

1310

rep = product2.get_rep(ind)

1311

1312

sol = product1.get_rep([0,0] + ind) - product1.get_rep([1,1] + ind) - \

1313

product1.get_rep([2,2] + ind) -product1.get_rep([3,3] + ind)

1314

1315

product1.get_rep([2,2] + ind),product1.get_rep([3,3] + ind)

1316

self.assertEqual(rep, sol)

1317

1318

1319

def testspincontraction(self):

1320

"""Test the spin contraction"""

1321

prod0 = self.gamma_mu_ij * self.gamma_nu_kl

1322

prod1 = self.gamma_mu_ij * self.gamma_nu_jk

1323

1324

#check global

1325

self.assertTrue(isinstance(prod1, HelasLib.LorentzObjectRepresentation))

1326

self.assertEquals(prod1.lorentz_ind, [2, 1])

1327

self.assertEqual(prod1.spin_ind, [1,3])

1328

1329

for ind in prod1.listindices():

1330

1331

rep = prod1.get_rep(ind)

1332

sol = prod0.get_rep([ind[0], ind[1], ind[2], 0, 0, ind[3]]) + \

1333

prod0.get_rep([ind[0], ind[1], ind[2], 1, 1, ind[3]]) + \

1334

prod0.get_rep([ind[0], ind[1], ind[2], 2, 2, ind[3]]) + \

1335

prod0.get_rep([ind[0], ind[1], ind[2], 3, 3, ind[3]])

1336

self.assertEqual(rep, sol)

1337

1338

1339

prod2 = self.gamma_mu_ij * self.gamma_mu_jk

1340

1341

#check global

1342

self.assertTrue(isinstance(prod2, HelasLib.LorentzObjectRepresentation))

1343

self.assertEquals(prod2.lorentz_ind, [])

1344

self.assertEqual(prod2.spin_ind, [1,3])

1345

1346

for ind in prod2.listindices():

1347

1348

rep = prod2.get_rep(ind)

1349

sol = prod1.get_rep([0, 0, ind[0], ind[1]]) \

1350

- prod1.get_rep([1, 1, ind[0], ind[1]]) + \

1351

- prod1.get_rep([2, 2, ind[0], ind[1]]) + \

1352

- prod1.get_rep([3, 3, ind[0], ind[1]])

1353

1354

self.assertEqual(rep, sol)

1355

1356

#test 3-> scalar

1357

prod3 = self.gamma_nu_ij * self.gamma_nu_ji

1358

1359

#check global

1360

self.assertTrue(isinstance(prod3, HelasLib.LorentzObjectRepresentation))

1361

self.assertEquals(prod3.lorentz_ind, [])

1362

self.assertEqual(prod3.spin_ind, [])

1363

1364

for ind in prod3.listindices():

1365

1366

rep = prod3.get_rep(ind)

1367

sol = prod2.get_rep([0,0]) \

1368

+ prod2.get_rep([1,1]) \

1369

+ prod2.get_rep([2,2]) \

1370

+ prod2.get_rep([3,3])

1371

self.assertEqual(rep, sol)

1372

1373

#test 4-> scalar

1374

prod3 = self.gamma_nu_ji * self.gamma_nu_ij

1375

1376

#check global

1377

self.assertTrue(isinstance(prod3, HelasLib.LorentzObjectRepresentation))

1378

self.assertEquals(prod3.lorentz_ind, [])

1379

self.assertEqual(prod3.spin_ind, [])

1380

1381

for ind in prod3.listindices():

1382

1383

rep = prod3.get_rep(ind)

1384

sol = prod2.get_rep([0,0]) \

1385

+ prod2.get_rep([1,1]) \

1386

+ prod2.get_rep([2,2]) \

1387

+ prod2.get_rep([3,3])

1388

self.assertEqual(rep, sol)

1389

1390

1391

1392

def testEinsteinsum(self):

1393

"""Test the Einstein summation"""

1394

1395

prod1 = self.p1nu * self.p2mu * self.p2nu

1396

1397

#check global

1398

self.assertTrue(isinstance(prod1, HelasLib.LorentzObjectRepresentation))

1399

self.assertEquals(prod1.lorentz_ind, [2])

1400

self.assertEqual(prod1.spin_ind, [])

1401

self.assertEqual(prod1.tag, set(['P1','P2']))

1402

1403

#check the representation

1404

for ind in prod1.listindices():

1405

rep = prod1.get_rep(ind)

1406

self.assertEqual(rep.__class__, HelasLib.AddVariable)

1407

self.assertEqual(len(rep), 4)

1408

for data in rep:

1409

self.assertEqual(data.__class__, HelasLib.MultVariable)

1410

power = [data2.power for data2 in data]

1411

power.sort()

1412

if len(power) == 2:

1413

self.assertEqual(power, [1,2])

1414

else:

1415

self.assertEqual(power, [1,1,1])

1416

1417

1418

# Returning a scalar

1419

prod2 = self.p1nu * self.p2nu

1420

1421

#check global

1422

self.assertTrue(isinstance(prod2, HelasLib.LorentzObjectRepresentation))

1423

self.assertEquals(prod2.lorentz_ind, [])

1424

self.assertEqual(prod2.spin_ind, [])

1425

self.assertEqual(prod2.tag, set(['P1','P2']))

1426

1427

#check the representation

1428

for ind in prod2.listindices():

1429

rep = prod2.get_rep(ind)

1430

self.assertEqual(rep.__class__, HelasLib.AddVariable)

1431

self.assertEqual(len(rep), 4)

1432

for data in rep:

1433

self.assertEqual(data.__class__, HelasLib.MultVariable)

1434

self.assertEqual(len(data), 2)

1435

self.assertNotEqual(data[0].variable, data[1].variable)

1436

1437

def testeinsteinsum2(self):

1438

1439

class gamma_in_lorentz(HelasLib.LorentzObject):

1440

""" local representation """

1441

1442

def __init__(self, l1, l2, prefactor=1, constant=0):

1443

HelasLib.LorentzObject.__init__(self,[l1, l2], [], [])

1444

1445

representation = HelasLib.LorentzObjectRepresentation(

1446

{(0,0): 0, (0,1): 0, (0,2): 0, (0,3):-1,

1447

(1,0): 0, (1,1): 0, (1,2): -1, (1,3):0,

1448

(2,0): 0, (2,1): 1, (2,2): 0, (2,3):0,

1449

(3,0): 1, (3,1): 0, (3,2): 0, (3,3):0

1450

}, [1,2], [], [])

1451

1452

create_representation = lambda : representation

1453

1454

obj = gamma_in_lorentz([1,2],[],[])

1455

1456

1457

obj2 = obj.expand()

1458

self.assertEqual(obj2.get_rep((0,3)), -1)

1459

self.assertEqual(obj2.get_rep((1,2)), -1)

1460

self.assertEqual(obj2.get_rep((2,1)), 1)

1461

self.assertEqual(obj2.get_rep((3,0)), 1)

1462

1463

new= obj * HelasObject.P(2,2)

1464

new = new.simplify()

1465

new = new.expand()

1466

new = new.simplify()

1467

self.assertEqual(new.__class__, HelasLib.LorentzObjectRepresentation)

1468

self.assertEqual(new.lorentz_ind, [1])

1469

self.assertEqual(new.get_rep([3]), HelasLib.ScalarVariable('P2_0'))

1470

self.assertEqual(new.get_rep([2]), HelasLib.ScalarVariable('P2_1'))

1471

self.assertEqual(new.get_rep([1]), HelasLib.ScalarVariable('P2_2'))

1472

self.assertEqual(new.get_rep([0]), HelasLib.ScalarVariable('P2_3'))

1473

self.assertEqual(new.get_rep([0]).prefactor, 1)

1474

self.assertEqual(new.get_rep([1]).prefactor, 1)

1475

self.assertEqual(new.get_rep([2]).prefactor, -1)

1476

self.assertEqual(new.get_rep([3]).prefactor, 1)

1477

1478

def testspinsum(self):

1479

1480

class gamma_in_spin(HelasLib.LorentzObject):

1481

""" local representation """

1482

1483

def __init__(self, s1, s2, prefactor=1, constant=0):

1484

HelasLib.LorentzObject.__init__(self, [], [s1, s2], [])

1485

1486

representation = HelasLib.LorentzObjectRepresentation(

1487

{(0,0): 0, (0,1): 0, (0,2): 0, (0,3):-1,

1488

(1,0): 0, (1,1): 0, (1,2): -1, (1,3):0,

1489

(2,0): 0, (2,1): 1, (2,2): 0, (2,3):0,

1490

(3,0): 1, (3,1): 0, (3,2): 0, (3,3):0},

1491

[], [1,2], [])

1492

1493

create_representation = lambda : representation

1494

1495

1496

obj = gamma_in_spin(1,2)

1497

1498

obj2 = obj.expand()

1499

self.assertEqual(obj2.get_rep((0,3)), -1)

1500

self.assertEqual(obj2.get_rep((1,2)), -1)

1501

self.assertEqual(obj2.get_rep((2,1)), 1)

1502

self.assertEqual(obj2.get_rep((3,0)), 1)

1503

1504

new= obj * HelasObject.Spinor(2,2)

1505

new = new.simplify()

1506

new = new.expand()

1507

new = new.simplify()

1508

self.assertEqual(new.__class__, HelasLib.LorentzObjectRepresentation)

1509

self.assertEqual(new.spin_ind, [1])

1510

self.assertEqual(new.get_rep([3]), HelasLib.ScalarVariable('F2_1'))

1511

self.assertEqual(new.get_rep([2]), HelasLib.ScalarVariable('F2_2'))

1512

self.assertEqual(new.get_rep([1]), HelasLib.ScalarVariable('F2_3'))

1513

self.assertEqual(new.get_rep([0]), HelasLib.ScalarVariable('F2_4'))

1514

self.assertEqual(new.get_rep([0]).prefactor, -1)

1515

self.assertEqual(new.get_rep([1]).prefactor, -1)

1516

self.assertEqual(new.get_rep([2]).prefactor, 1)

1517

self.assertEqual(new.get_rep([3]).prefactor, 1)

1518

1519

1520

1521

def testsumofLorentzObj(self):

1522

""" Check the sumation of LorentzObject"""

1523

1524

sum = self.p1nu + self.p2nu

1525

1526

#check global

1527

self.assertTrue(isinstance(sum, HelasLib.LorentzObjectRepresentation))

1528

self.assertEquals(sum.lorentz_ind, [1])

1529

self.assertEqual(sum.spin_ind, [])

1530

self.assertEqual(sum.tag, set(['P1','P2']))

1531

1532

#check the representation

1533

for ind in sum.listindices():

1534

rep = sum.get_rep(ind)

1535

self.assertEqual(rep.__class__, HelasLib.AddVariable)

1536

self.assertEqual(len(rep), 2)

1537

for data in rep:

1538

self.assertEqual(data.__class__, HelasLib.ScalarVariable)

1539

1540

##

1541

## check more complex with indices in wrong order

1542

##

1543

1544

sum = self.p1nu * self.p2mu + self.p1mu * self.p2nu

1545

1546

#check global

1547

self.assertTrue(isinstance(sum, HelasLib.LorentzObjectRepresentation))

1548

self.assertEquals(sum.lorentz_ind, [1, 2])

1549

self.assertEqual(sum.spin_ind, [])

1550

tag = set(list(sum.tag))

1551

1552

#check the representation

1553

for ind in sum.listindices():

1554

rep = sum.get_rep(ind)

1555

if rep.prefactor == 1:

1556

self.assertEqual(rep.__class__, HelasLib.AddVariable)

1557

self.assertEqual(len(rep), 2)

1558

for data in rep:

1559

self.assertEqual(data.__class__, HelasLib.MultVariable)

1560

self.assertEqual(data.prefactor, 1)

1561

else:

1562

self.assertEqual(rep.__class__, HelasLib.MultVariable)

1563

self.assertEqual(len(rep), 2)

1564

self.assertEqual(rep.prefactor,2)

1565

sum2 = sum - (self.p1nu * self.p2mu + self.p2nu * self.p1mu)

1566

sum2 = sum2.simplify()

1567

for ind in sum2.listindices():

1568

rep = sum2.get_rep(ind)

1569

self.assertEqual(rep, 0)

1570

1571

1572

#check sum is unchanged

1573

self.assertTrue(isinstance(sum, HelasLib.LorentzObjectRepresentation))

1574

self.assertEquals(sum.lorentz_ind, [1, 2])

1575

self.assertEqual(sum.spin_ind, [])

1576

self.assertEqual(sum.tag, tag)

1577

for ind in sum.listindices():

1578

rep = sum.get_rep(ind)

1579

if rep.prefactor == 1:

1580

self.assertEqual(rep.__class__, HelasLib.AddVariable)

1581

self.assertEqual(len(rep), 2)

1582

for data in rep:

1583

self.assertEqual(data.__class__, HelasLib.MultVariable)

1584

self.assertEqual(data.prefactor,1)

1585

else:

1586

self.assertEqual(rep.__class__, HelasLib.MultVariable)

1587

self.assertEqual(len(rep), 2)

1588

self.assertEqual(rep.prefactor,2)

1589

self.assertEqual(sum, self.p1nu * self.p2mu + self.p1mu * self.p2nu)

1590

1591

sumbis = self.p1nu * self.p2mu + self.p1mu * self.p2nu

1592

for ind in sumbis.listindices():

1593

self.assertEqual(sumbis.get_rep(ind),sum.get_rep(ind))

1594

1595

sum -= sumbis

1596

sum = sum.simplify()

1597

for ind in sum.listindices():

1598

rep = sum.get_rep(ind)

1599

self.assertEqual(rep, 0)

1600

self.assertEqual(sum,sum2)

1601

1602

#check wrong sum

1603

self.assertRaises( \

1604

HelasLib.LorentzObjectRepresentation.LorentzObjectRepresentationError, \

1605

HelasLib.LorentzObjectRepresentation.__add__,self.p1nu,self.p2mu)

1606

1607

class TestSomeObjectProperty(unittest.TestCase):

1608

"""Test that some property pass correctly for Object"""

1609

1610

def testmassisdiffaswidth(self):

1611

"""Ensure that a mass object is different of a width object"""

1612

1613

mass = HelasObject.Mass(1)

1614

width = HelasObject.Width(1)

1615

self.assertNotEqual(mass, width)

1616

self.assertNotEqual(mass * mass, mass * width)

1617

1618

1619

mass = mass.expand()

1620

width = width.expand()

1621

self.assertNotEqual(mass, width)

1622

self.assertNotEqual(mass * mass, mass * width)

1623

1624

mass = mass.simplify()

1625

width = width.simplify()

1626

self.assertNotEqual(mass, width)

1627

self.assertNotEqual(mass * mass, mass * width)

1628

1629

mass = HelasObject.Mass(1)

1630

width = HelasObject.Width(1)

1631

sum = mass * mass + mass * width

1632

sum.simplify()

1633

self.assertEqual(sum.__class__, HelasLib.AddVariable)

1634

self.assertEqual(len(sum), 2)

1635

1636

def testIdentityMatrix(self):

1637

""" Test the Identity Matrix"""

1638

Identity = HelasObject.Identity

1639

Gamma = HelasObject.Gamma

1640

Gamma5 = HelasObject.Gamma5

1641

Metric = HelasObject.Metric

1642

1643

#Test that Identity is idenpotent

1644

obj1 = Identity(1,2).expand()

1645

obj2 = Identity(1,3).expand() * Identity(3,2).expand()

1646

self.assertEqual(obj1.lorentz_ind, obj2.lorentz_ind)

1647

self.assertEqual(obj1.spin_ind, obj2.spin_ind)

1648

self.assertEqual(obj1, obj2)

1649

1650

#Test at low level

1651

obj1 = Gamma(1,1,2).expand()

1652

obj2 = Identity(1,3).expand() * Gamma(1,3,2).expand()

1653

self.assertEqual(obj1.lorentz_ind, obj2.lorentz_ind)

1654

self.assertEqual(obj1.spin_ind, obj2.spin_ind)

1655

self.assertEqual(obj1, obj2)

1656

1657

#Gamma = Identity * Gamma

1658

obj1 = Gamma(1,1,2)

1659

obj2 = Identity(1,3) * Gamma(1,3,2)

1660

obj1 = obj1.simplify().expand().simplify()

1661

obj2 = obj2.simplify().expand().simplify()

1662

self.assertEqual(obj1.lorentz_ind, obj2.lorentz_ind)

1663

self.assertEqual(set(obj1.spin_ind), set(obj2.spin_ind))

1664

for ind in obj1.listindices():

1665

if obj1.spin_ind == obj2.spin_ind:

1666

mapind = lambda ind : ind

1667

else:

1668

mapind = lambda ind : [ind[0],ind[2],ind[1]]

1669

self.assertEqual(obj1.get_rep(ind),obj2.get_rep(mapind(ind)))

1670

1671

1672

#self.assertEqual(obj1, obj2)

1673

1674

#Gamma = Identity * Identity * Gamma

1675

#at low level

1676

obj1 = Gamma(1,1,2).expand()

1677

obj2 = Identity(3,4).expand() * Gamma(1,4,2).expand()

1678

obj3 = Identity(1,3).expand() *obj2

1679

self.assertEqual(obj1.lorentz_ind, obj2.lorentz_ind)

1680

self.assertEqual(obj1.lorentz_ind, obj3.lorentz_ind)

1681

self.assertEqual(obj2.spin_ind, [3,2])

1682

self.assertEqual(obj1.spin_ind, obj3.spin_ind)

1683

for ind in obj1.listindices():

1684

self.assertEqual(obj1.get_rep(ind),obj3.get_rep(ind))

1685

self.assertEqual(obj1, obj3)

1686

1687

#at High Level

1688

obj1 = Gamma(1,1,2)

1689

obj2 = Identity(1,3) * Identity(3,4)

1690

obj3 = obj2 * Gamma(1,4,2)

1691

obj1 = obj1.simplify().expand().simplify()

1692

obj2 = obj2.simplify().expand().simplify()

1693

obj3 = obj3.simplify().expand().simplify()

1694

#self.assertEqual(obj1.lorentz_ind, obj2.lorentz_ind)

1695

self.assertEqual(obj1.lorentz_ind, obj3.lorentz_ind)

1696

self.assertEqual(set(obj2.spin_ind), set([1,4]))

1697

self.assertEqual(set(obj1.spin_ind), set(obj3.spin_ind))

1698

for ind in obj1.listindices():

1699

if obj1.spin_ind == obj3.spin_ind:

1700

mapind = lambda ind : ind

1701

else:

1702

mapind = lambda ind : [ind[0],ind[2],ind[1]]

1703

self.assertEqual(obj1.get_rep(ind),obj3.get_rep(mapind(ind)))

1704

#self.assertEqual(obj1, obj3)

1705

1706

#at High Level

1707

obj1 = Gamma(1,1,2)

1708

obj2 = Identity(1,3) * Identity(3,4) * Gamma(1,4,2)

1709

obj1 = obj1.simplify().expand().simplify()

1710

obj2 = obj2.simplify().expand().simplify()

1711

self.assertEqual(obj1.lorentz_ind, obj2.lorentz_ind)

1712

self.assertEqual(set(obj2.spin_ind), set([1,2]))

1713

self.assertEqual(set(obj1.spin_ind), set(obj2.spin_ind))

1714

for ind in obj1.listindices():

1715

if obj1.spin_ind == obj2.spin_ind:

1716

mapind = lambda ind : ind

1717

else:

1718

mapind = lambda ind : [ind[0],ind[2],ind[1]]

1719

self.assertEqual(obj1.get_rep(ind),obj2.get_rep(mapind(ind)))

1720

#self.assertEqual(obj1, obj2)

1721

1722

def testGammaAlgebra(self):

1723

"""Test the coherence between gamma/gamma5/sigma/projector"""

1724

Gamma = HelasObject.Gamma

1725

Gamma5 = HelasObject.Gamma5

1726

Sigma = HelasObject.Sigma

1727

ProjM = HelasObject.ProjM

1728

ProjP = HelasObject.ProjP

1729

Identity = HelasObject.Identity

1730

Metric = HelasObject.Metric

1731

1732

#Gamma5 = i *Gamma0 * Gamma1 * Gamma2 * Gamma3

1733

gamma5 = complex(0,1) * Gamma(0,1,2) * Gamma(1,2,3) * Gamma(2,3,4) * \

1734

Gamma(3,4,5)

1735

self.assertEqual(gamma5.__class__,HelasLib.MultLorentz)

1736

self.assertEqual(gamma5.prefactor, complex(0,1))

1737

1738

gamma5_2 = Gamma5(1,5)

1739

1740

gamma5 = gamma5.expand().simplify()

1741

gamma5_2 = gamma5_2.expand().simplify()

1742

1743

for ind in gamma5_2.listindices():

1744

component1 = gamma5.get_rep([0,1,2,3] + ind)

1745

component2 = gamma5_2.get_rep(ind)

1746

self.assertEqual(component1, component2)

1747

1748

#ProjP = (1+ Gamma5)/2

1749

1750

projp = 1/2 * (Identity(1,2) + Gamma5(1,2))

1751

projp = projp.simplify()

1752

projp = projp.expand()

1753

projp = projp.simplify()

1754

1755

projp2 = ProjP(1,2)

1756

projp2 = projp2.simplify()

1757

projp2 = projp2.expand()

1758

projp2 = projp2.simplify()

1759

1760

self.assertEqual(projp,projp2)

1761

1762

#ProjM = (1 - Gamma5)/2

1763

1764

projm = 1/2 * (Identity(1,2) - Gamma5(1,2))

1765

projm = projm.simplify()

1766

projm = projm.expand()

1767

projm = projm.simplify()

1768

1769

projm2 = ProjM(1,2)

1770

projm2 = projm2.simplify()

1771

projm2 = projm2.expand()

1772

projm2 = projm2.simplify()

1773

1774

self.assertEqual(projm,projm2)

1775

1776

# Identity = ProjP + ProjM

1777

identity= ProjM(1,2) + ProjP(1,2)

1778

identity = identity.simplify().expand().simplify()

1779

1780

identity2 = Identity(1,2)

1781

identity2 = identity2.simplify().expand().simplify()

1782

1783

self.assertEqual(identity,identity2)

1784

1785

#metric_mu_nu = 1/2 {Gamma_nu, Gamma_mu}

1786

metric = 1/2 * (Gamma(1,1,2)*Gamma(2,2,3) + Gamma(2,1,2)*Gamma(1,2,3))

1787

metric = metric.simplify().expand().simplify()

1788

1789

metric2 = Metric(1,2) * Identity(1,3)

1790

metric2 = metric2.simplify().expand().simplify()

1791

self.assertEqual(metric, metric2)

1792

1793

#Sigma_mu_nu = 1/(2i) * [Gamma_mu, Gamma_nu]

1794

sigma = complex(0, 1/2) * (Gamma(1,1,2)*Gamma(2,2,3) - Gamma(2,1,2)*Gamma(1,2,3))

1795

sigma = sigma.simplify().expand().simplify()

1796

1797

sigma2 = Sigma(1,2,1,3)

1798

sigma2 = sigma2.simplify().expand().simplify()

1799

self.assertEqual(sigma, sigma2)

1800

1801

def testemptyisFalse(self):

1802

1803

false = HelasLib.AddVariable([])

1804

if false:

1805

raise AssertionError, 'empty list are not False'

1806

1807

false = HelasLib.MultVariable([])

1808

if false:

1809

raise AssertionError, 'empty list are not False'

1810

1811

class TestConstantObject(unittest.TestCase):

1812

"""Check the different Operation for a Constant Object"""

1813

1814

def testsum(self):

1815

1816

const = HelasLib.ConstantObject()

1817

p = HelasObject.P(1,1)

1818

1819

sum = const + p

1820

self.assertEqual(type(sum),type(p))

1821

self.assertEqual(sum, p)

1822

1823

p2 = HelasObject.P(1,2)

1824

add = p + p2

1825

1826

class TestSimplify(unittest.TestCase):

1827

"""Check that the simplification works correctly"""

1828

1829

def testsimplifyMultLorentz(self):

1830

1831

# For Standard Product : No Simplification

1832

prod = HelasObject.Gamma(1, 2, 3) * HelasObject.Gamma(3, 4, 5)

1833

1834

simp = prod.simplify()

1835

self.assertEqual(simp, prod)

1836

1837

# Look if Multiply by Propagator

1838

prod = HelasObject.Gamma(1, 2, 3) * HelasObject.SpinorPropagator(1, 2 ,3) / \

1839

HelasObject.DenominatorPropagator(3)

1840

simp = prod.simplify()

1841

1842

self.assertEqual(simp.__class__, HelasLib.FracVariable)

1843

self.assertEqual(simp.denominator.__class__, HelasLib.AddVariable)

1844

simp = simp.expand()

1845

simp = simp.simplify()

1846

self.assertEqual(simp.denominator.__class__, HelasLib.LorentzObjectRepresentation)

1847

denominator = simp.denominator.get_rep([0])

1848

for data in denominator:

1849

if HelasLib.ScalarVariable('P3_0') == data:

1850

self.assertEqual(data.prefactor, 1)

1851

self.assertEqual(data.power, 2)

1852

elif HelasLib.ScalarVariable('P3_1') == data:

1853

self.assertEqual(data.prefactor, -1)

1854

self.assertEqual(data.power, 2)

1855

elif HelasLib.ScalarVariable('P3_2') == data:

1856

self.assertEqual(data.prefactor, -1)

1857

self.assertEqual(data.power, 2)

1858

elif HelasLib.ScalarVariable('P3_3') == data:

1859

self.assertEqual(data.prefactor, -1)

1860

self.assertEqual(data.power, 2)

1861

elif HelasLib.ScalarVariable('M3') == data:

1862

self.assertEqual(data.prefactor, -1)

1863

self.assertEqual(data.power, 2)

1864

elif HelasLib.ScalarVariable('W3') in data:

1865

self.assertEqual(data.prefactor, complex(0,1))

1866

1867

1868

1869

def testsimplifyFracVariable(self):

1870

1871

# For Standard Product : No Simplification

1872

prod = HelasObject.Gamma(1, 2, 3) * HelasObject.Gamma(3, 4, 5)

1873

1874

simp = prod.simplify()

1875

self.assertEqual(simp, prod)

1876

1877

# Look if Multiply by Propagator

1878

1879

prod = HelasObject.Gamma(1, 2, 3) * HelasObject.SpinorPropagator(1, 2 ,3) / \

1880

HelasObject.DenominatorPropagator(3)

1881

simp = prod.simplify()

1882

1883

self.assertEqual(simp.__class__, HelasLib.FracVariable)

1884

self.assertEqual(simp.denominator.__class__, HelasLib.AddVariable)

1885

1886

b'\\ No newline at end of file'

~sebastien-wertz/mg5amcnlo/standalone_cpp_mem