foscat 3.2.0__py3-none-any.whl → 3.3.1__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (23) hide show
  1. foscat/CircSpline.py +61 -40
  2. foscat/FoCUS.py +3 -3
  3. foscat/Softmax.py +1 -1
  4. foscat/Spline1D.py +88 -42
  5. foscat/Synthesis.py +23 -9
  6. foscat/alm.py +140 -0
  7. foscat/backend.py +44 -25
  8. foscat/backend_tens.py +2 -1
  9. foscat/loss_backend_torch.py +0 -1
  10. foscat/scat.py +15 -6
  11. foscat/scat1D.py +15 -6
  12. foscat/scat_cov.py +993 -931
  13. foscat/scat_cov1D.py +2 -2
  14. foscat/scat_cov2D.py +2 -2
  15. foscat/scat_cov_map.py +16 -16
  16. foscat/scat_cov_map2D.py +16 -16
  17. {foscat-3.2.0.dist-info → foscat-3.3.1.dist-info}/METADATA +39 -30
  18. foscat-3.3.1.dist-info/RECORD +26 -0
  19. {foscat-3.2.0.dist-info → foscat-3.3.1.dist-info}/WHEEL +1 -1
  20. foscat/scat_cov1D.old.py +0 -1547
  21. foscat-3.2.0.dist-info/RECORD +0 -26
  22. {foscat-3.2.0.dist-info → foscat-3.3.1.dist-info}/LICENCE +0 -0
  23. {foscat-3.2.0.dist-info → foscat-3.3.1.dist-info}/top_level.txt +0 -0
foscat/scat_cov.py CHANGED
@@ -6,7 +6,7 @@ import numpy as np
6
6
 
7
7
  import foscat as foscat
8
8
 
9
- #import foscat.backend as bk
9
+ # import foscat.backend as bk
10
10
  import foscat.FoCUS as FOC
11
11
 
12
12
  # Vérifier si TensorFlow est importé et défini
@@ -34,14 +34,14 @@ testwarn = 0
34
34
 
35
35
  class scat_cov:
36
36
  def __init__(
37
- self, s0, p00, c01, c11, s1=None, c10=None, backend=None, use_1D=False
37
+ self, s0, s2, s3, s4, s1=None, s3p=None, backend=None, use_1D=False
38
38
  ):
39
39
  self.S0 = s0
40
- self.P00 = p00
41
- self.C01 = c01
42
- self.C11 = c11
40
+ self.S2 = s2
41
+ self.S3 = s3
42
+ self.S4 = s4
43
43
  self.S1 = s1
44
- self.C10 = c10
44
+ self.S3P = s3p
45
45
  self.backend = backend
46
46
  self.idx1 = None
47
47
  self.idx2 = None
@@ -55,18 +55,18 @@ class scat_cov:
55
55
  s1 = None
56
56
  else:
57
57
  s1 = self.S1.numpy()
58
- if self.C10 is None:
59
- c10 = None
58
+ if self.S3P is None:
59
+ s3p = None
60
60
  else:
61
- c10 = self.C10.numpy()
61
+ s3p = self.S3P.numpy()
62
62
 
63
63
  return scat_cov(
64
64
  (self.S0.numpy()),
65
- (self.P00.numpy()),
66
- (self.C01.numpy()),
67
- (self.C11.numpy()),
65
+ (self.S2.numpy()),
66
+ (self.S3.numpy()),
67
+ (self.S4.numpy()),
68
68
  s1=s1,
69
- c10=c10,
69
+ s3p=s3p,
70
70
  backend=self.backend,
71
71
  use_1D=self.use_1D,
72
72
  )
@@ -77,18 +77,18 @@ class scat_cov:
77
77
  s1 = None
78
78
  else:
79
79
  s1 = self.backend.constant(self.S1)
80
- if self.C10 is None:
81
- c10 = None
80
+ if self.S3P is None:
81
+ s3p = None
82
82
  else:
83
- c10 = self.backend.constant(self.C10)
83
+ s3p = self.backend.constant(self.S3P)
84
84
 
85
85
  return scat_cov(
86
86
  self.backend.constant(self.S0),
87
- self.backend.constant(self.P00),
88
- self.backend.constant(self.C01),
89
- self.backend.constant(self.C11),
87
+ self.backend.constant(self.S2),
88
+ self.backend.constant(self.S3),
89
+ self.backend.constant(self.S4),
90
90
  s1=s1,
91
- c10=c10,
91
+ s3p=s3p,
92
92
  backend=self.backend,
93
93
  use_1D=self.use_1D,
94
94
  )
@@ -120,23 +120,23 @@ class scat_cov:
120
120
  tmp = tmp + [
121
121
  self.conv2complex(
122
122
  self.backend.bk_reshape(
123
- self.P00,
123
+ self.S2,
124
124
  [self.S1.shape[0], self.S1.shape[1] * self.S1.shape[2]],
125
125
  )
126
126
  ),
127
127
  self.conv2complex(
128
128
  self.backend.bk_reshape(
129
- self.C01,
130
- [self.C01.shape[0], self.C01.shape[1] * self.C01.shape[2]],
129
+ self.S3,
130
+ [self.S3.shape[0], self.S3.shape[1] * self.S3.shape[2]],
131
131
  )
132
132
  ),
133
133
  ]
134
- if self.C10 is not None:
134
+ if self.S3P is not None:
135
135
  tmp = tmp + [
136
136
  self.conv2complex(
137
137
  self.backend.bk_reshape(
138
- self.C10,
139
- [self.C01.shape[0], self.C01.shape[1] * self.C01.shape[2]],
138
+ self.S3P,
139
+ [self.S3.shape[0], self.S3.shape[1] * self.S3.shape[2]],
140
140
  )
141
141
  )
142
142
  ]
@@ -144,8 +144,8 @@ class scat_cov:
144
144
  tmp = tmp + [
145
145
  self.conv2complex(
146
146
  self.backend.bk_reshape(
147
- self.C11,
148
- [self.C01.shape[0], self.C11.shape[1] * self.C11.shape[2]],
147
+ self.S4,
148
+ [self.S3.shape[0], self.S4.shape[1] * self.S4.shape[2]],
149
149
  )
150
150
  )
151
151
  ]
@@ -167,7 +167,7 @@ class scat_cov:
167
167
  tmp = tmp + [
168
168
  self.conv2complex(
169
169
  self.backend.bk_reshape(
170
- self.P00,
170
+ self.S2,
171
171
  [
172
172
  self.S1.shape[0],
173
173
  self.S1.shape[1] * self.S1.shape[2] * self.S1.shape[3],
@@ -176,28 +176,28 @@ class scat_cov:
176
176
  ),
177
177
  self.conv2complex(
178
178
  self.backend.bk_reshape(
179
- self.C01,
179
+ self.S3,
180
180
  [
181
- self.C01.shape[0],
182
- self.C01.shape[1]
183
- * self.C01.shape[2]
184
- * self.C01.shape[3]
185
- * self.C01.shape[4],
181
+ self.S3.shape[0],
182
+ self.S3.shape[1]
183
+ * self.S3.shape[2]
184
+ * self.S3.shape[3]
185
+ * self.S3.shape[4],
186
186
  ],
187
187
  )
188
188
  ),
189
189
  ]
190
- if self.C10 is not None:
190
+ if self.S3P is not None:
191
191
  tmp = tmp + [
192
192
  self.conv2complex(
193
193
  self.backend.bk_reshape(
194
- self.C10,
194
+ self.S3P,
195
195
  [
196
- self.C01.shape[0],
197
- self.C01.shape[1]
198
- * self.C01.shape[2]
199
- * self.C01.shape[3]
200
- * self.C01.shape[4],
196
+ self.S3.shape[0],
197
+ self.S3.shape[1]
198
+ * self.S3.shape[2]
199
+ * self.S3.shape[3]
200
+ * self.S3.shape[4],
201
201
  ],
202
202
  )
203
203
  )
@@ -206,14 +206,14 @@ class scat_cov:
206
206
  tmp = tmp + [
207
207
  self.conv2complex(
208
208
  self.backend.bk_reshape(
209
- self.C11,
209
+ self.S4,
210
210
  [
211
- self.C01.shape[0],
212
- self.C11.shape[1]
213
- * self.C11.shape[2]
214
- * self.C11.shape[3]
215
- * self.C11.shape[4]
216
- * self.C11.shape[5],
211
+ self.S3.shape[0],
212
+ self.S4.shape[1]
213
+ * self.S4.shape[2]
214
+ * self.S4.shape[3]
215
+ * self.S4.shape[4]
216
+ * self.S4.shape[5],
217
217
  ],
218
218
  )
219
219
  )
@@ -223,15 +223,15 @@ class scat_cov:
223
223
 
224
224
  # ---------------------------------------------−---------
225
225
  def flattenMask(self):
226
- if isinstance(self.P00, np.ndarray):
226
+ if isinstance(self.S2, np.ndarray):
227
227
  if self.S1 is None:
228
- if self.C10 is None:
228
+ if self.S3P is None:
229
229
  tmp = np.concatenate(
230
230
  [
231
231
  self.S0[0].flatten(),
232
- self.P00[0].flatten(),
233
- self.C01[0].flatten(),
234
- self.C11[0].flatten(),
232
+ self.S2[0].flatten(),
233
+ self.S3[0].flatten(),
234
+ self.S4[0].flatten(),
235
235
  ],
236
236
  0,
237
237
  )
@@ -239,22 +239,22 @@ class scat_cov:
239
239
  tmp = np.concatenate(
240
240
  [
241
241
  self.S0[0].flatten(),
242
- self.P00[0].flatten(),
243
- self.C01[0].flatten(),
244
- self.C10[0].flatten(),
245
- self.C11[0].flatten(),
242
+ self.S2[0].flatten(),
243
+ self.S3[0].flatten(),
244
+ self.S3P[0].flatten(),
245
+ self.S4[0].flatten(),
246
246
  ],
247
247
  0,
248
248
  )
249
249
  else:
250
- if self.C10 is None:
250
+ if self.S3P is None:
251
251
  tmp = np.concatenate(
252
252
  [
253
253
  self.S0[0].flatten(),
254
254
  self.S1[0].flatten(),
255
- self.P00[0].flatten(),
256
- self.C01[0].flatten(),
257
- self.C11[0].flatten(),
255
+ self.S2[0].flatten(),
256
+ self.S3[0].flatten(),
257
+ self.S4[0].flatten(),
258
258
  ],
259
259
  0,
260
260
  )
@@ -263,24 +263,24 @@ class scat_cov:
263
263
  [
264
264
  self.S0[0].flatten(),
265
265
  self.S1[0].flatten(),
266
- self.P00[0].flatten(),
267
- self.C01[0].flatten(),
268
- self.C10[0].flatten(),
269
- self.C11[0].flatten(),
266
+ self.S2[0].flatten(),
267
+ self.S3[0].flatten(),
268
+ self.S3P[0].flatten(),
269
+ self.S4[0].flatten(),
270
270
  ],
271
271
  0,
272
272
  )
273
273
  tmp = np.expand_dims(tmp, 0)
274
274
 
275
- for k in range(1, self.P00.shape[0]):
275
+ for k in range(1, self.S2.shape[0]):
276
276
  if self.S1 is None:
277
- if self.C10 is None:
277
+ if self.S3P is None:
278
278
  ltmp = np.concatenate(
279
279
  [
280
280
  self.S0[k].flatten(),
281
- self.P00[k].flatten(),
282
- self.C01[k].flatten(),
283
- self.C11[k].flatten(),
281
+ self.S2[k].flatten(),
282
+ self.S3[k].flatten(),
283
+ self.S4[k].flatten(),
284
284
  ],
285
285
  0,
286
286
  )
@@ -288,22 +288,22 @@ class scat_cov:
288
288
  ltmp = np.concatenate(
289
289
  [
290
290
  self.S0[k].flatten(),
291
- self.P00[k].flatten(),
292
- self.C01[k].flatten(),
293
- self.C10[k].flatten(),
294
- self.C11[k].flatten(),
291
+ self.S2[k].flatten(),
292
+ self.S3[k].flatten(),
293
+ self.S3P[k].flatten(),
294
+ self.S4[k].flatten(),
295
295
  ],
296
296
  0,
297
297
  )
298
298
  else:
299
- if self.C10 is None:
299
+ if self.S3P is None:
300
300
  ltmp = np.concatenate(
301
301
  [
302
302
  self.S0[k].flatten(),
303
303
  self.S1[k].flatten(),
304
- self.P00[k].flatten(),
305
- self.C01[k].flatten(),
306
- self.C11[k].flatten(),
304
+ self.S2[k].flatten(),
305
+ self.S3[k].flatten(),
306
+ self.S4[k].flatten(),
307
307
  ],
308
308
  0,
309
309
  )
@@ -312,10 +312,10 @@ class scat_cov:
312
312
  [
313
313
  self.S0[k].flatten(),
314
314
  self.S1[k].flatten(),
315
- self.P00[k].flatten(),
316
- self.C01[k].flatten(),
317
- self.C10[k].flatten(),
318
- self.C11[k].flatten(),
315
+ self.S2[k].flatten(),
316
+ self.S3[k].flatten(),
317
+ self.S3P[k].flatten(),
318
+ self.S4[k].flatten(),
319
319
  ],
320
320
  0,
321
321
  )
@@ -325,13 +325,13 @@ class scat_cov:
325
325
  return tmp
326
326
  else:
327
327
  if self.S1 is None:
328
- if self.C10 is None:
328
+ if self.S3P is None:
329
329
  tmp = self.backend.bk_concat(
330
330
  [
331
331
  self.backend.bk_flattenR(self.S0[0]),
332
- self.backend.bk_flattenR(self.P00[0]),
333
- self.backend.bk_flattenR(self.C01[0]),
334
- self.backend.bk_flattenR(self.C11[0]),
332
+ self.backend.bk_flattenR(self.S2[0]),
333
+ self.backend.bk_flattenR(self.S3[0]),
334
+ self.backend.bk_flattenR(self.S4[0]),
335
335
  ],
336
336
  0,
337
337
  )
@@ -339,22 +339,22 @@ class scat_cov:
339
339
  tmp = self.backend.bk_concat(
340
340
  [
341
341
  self.backend.bk_flattenR(self.S0[0]),
342
- self.backend.bk_flattenR(self.P00[0]),
343
- self.backend.bk_flattenR(self.C01[0]),
344
- self.backend.bk_flattenR(self.C10[0]),
345
- self.backend.bk_flattenR(self.C11[0]),
342
+ self.backend.bk_flattenR(self.S2[0]),
343
+ self.backend.bk_flattenR(self.S3[0]),
344
+ self.backend.bk_flattenR(self.S3P[0]),
345
+ self.backend.bk_flattenR(self.S4[0]),
346
346
  ],
347
347
  0,
348
348
  )
349
349
  else:
350
- if self.C10 is None:
350
+ if self.S3P is None:
351
351
  tmp = self.backend.bk_concat(
352
352
  [
353
353
  self.backend.bk_flattenR(self.S0[0]),
354
354
  self.backend.bk_flattenR(self.S1[0]),
355
- self.backend.bk_flattenR(self.P00[0]),
356
- self.backend.bk_flattenR(self.C01[0]),
357
- self.backend.bk_flattenR(self.C11[0]),
355
+ self.backend.bk_flattenR(self.S2[0]),
356
+ self.backend.bk_flattenR(self.S3[0]),
357
+ self.backend.bk_flattenR(self.S4[0]),
358
358
  ],
359
359
  0,
360
360
  )
@@ -363,24 +363,24 @@ class scat_cov:
363
363
  [
364
364
  self.backend.bk_flattenR(self.S0[0]),
365
365
  self.backend.bk_flattenR(self.S1[0]),
366
- self.backend.bk_flattenR(self.P00[0]),
367
- self.backend.bk_flattenR(self.C01[0]),
368
- self.backend.bk_flattenR(self.C10[0]),
369
- self.backend.bk_flattenR(self.C11[0]),
366
+ self.backend.bk_flattenR(self.S2[0]),
367
+ self.backend.bk_flattenR(self.S3[0]),
368
+ self.backend.bk_flattenR(self.S3P[0]),
369
+ self.backend.bk_flattenR(self.S4[0]),
370
370
  ],
371
371
  0,
372
372
  )
373
373
  tmp = self.backend.bk_expand_dims(tmp, 0)
374
374
 
375
- for k in range(1, self.P00.shape[0]):
375
+ for k in range(1, self.S2.shape[0]):
376
376
  if self.S1 is None:
377
- if self.C10 is None:
377
+ if self.S3P is None:
378
378
  ltmp = self.backend.bk_concat(
379
379
  [
380
380
  self.backend.bk_flattenR(self.S0[k]),
381
- self.backend.bk_flattenR(self.P00[k]),
382
- self.backend.bk_flattenR(self.C01[k]),
383
- self.backend.bk_flattenR(self.C11[k]),
381
+ self.backend.bk_flattenR(self.S2[k]),
382
+ self.backend.bk_flattenR(self.S3[k]),
383
+ self.backend.bk_flattenR(self.S4[k]),
384
384
  ],
385
385
  0,
386
386
  )
@@ -388,22 +388,22 @@ class scat_cov:
388
388
  ltmp = self.backend.bk_concat(
389
389
  [
390
390
  self.backend.bk_flattenR(self.S0[k]),
391
- self.backend.bk_flattenR(self.P00[k]),
392
- self.backend.bk_flattenR(self.C01[k]),
393
- self.backend.bk_flattenR(self.C10[k]),
394
- self.backend.bk_flattenR(self.C11[k]),
391
+ self.backend.bk_flattenR(self.S2[k]),
392
+ self.backend.bk_flattenR(self.S3[k]),
393
+ self.backend.bk_flattenR(self.S3P[k]),
394
+ self.backend.bk_flattenR(self.S4[k]),
395
395
  ],
396
396
  0,
397
397
  )
398
398
  else:
399
- if self.C10 is None:
399
+ if self.S3P is None:
400
400
  ltmp = self.backend.bk_concat(
401
401
  [
402
402
  self.backend.bk_flattenR(self.S0[k]),
403
403
  self.backend.bk_flattenR(self.S1[k]),
404
- self.backend.bk_flattenR(self.P00[k]),
405
- self.backend.bk_flattenR(self.C01[k]),
406
- self.backend.bk_flattenR(self.C11[k]),
404
+ self.backend.bk_flattenR(self.S2[k]),
405
+ self.backend.bk_flattenR(self.S3[k]),
406
+ self.backend.bk_flattenR(self.S4[k]),
407
407
  ],
408
408
  0,
409
409
  )
@@ -412,10 +412,10 @@ class scat_cov:
412
412
  [
413
413
  self.backend.bk_flattenR(self.S0[k]),
414
414
  self.backend.bk_flattenR(self.S1[k]),
415
- self.backend.bk_flattenR(self.P00[k]),
416
- self.backend.bk_flattenR(self.C01[k]),
417
- self.backend.bk_flattenR(self.C10[k]),
418
- self.backend.bk_flattenR(self.C11[k]),
415
+ self.backend.bk_flattenR(self.S2[k]),
416
+ self.backend.bk_flattenR(self.S3[k]),
417
+ self.backend.bk_flattenR(self.S3P[k]),
418
+ self.backend.bk_flattenR(self.S4[k]),
419
419
  ],
420
420
  0,
421
421
  )
@@ -432,23 +432,23 @@ class scat_cov:
432
432
  def get_S1(self):
433
433
  return self.S1
434
434
 
435
- def get_P00(self):
436
- return self.P00
435
+ def get_S2(self):
436
+ return self.S2
437
437
 
438
- def reset_P00(self):
439
- self.P00 = 0 * self.P00
438
+ def reset_S2(self):
439
+ self.S2 = 0 * self.S2
440
440
 
441
- def get_C01(self):
442
- return self.C01
441
+ def get_S3(self):
442
+ return self.S3
443
443
 
444
- def get_C10(self):
445
- return self.C10
444
+ def get_S3P(self):
445
+ return self.S3P
446
446
 
447
- def get_C11(self):
448
- return self.C11
447
+ def get_S4(self):
448
+ return self.S4
449
449
 
450
450
  def get_j_idx(self):
451
- shape = list(self.P00.shape)
451
+ shape = list(self.S2.shape)
452
452
  if len(shape) == 3:
453
453
  nscale = shape[2]
454
454
  elif len(shape) == 4:
@@ -468,8 +468,8 @@ class scat_cov:
468
468
 
469
469
  return j1, j2
470
470
 
471
- def get_jc11_idx(self):
472
- shape = list(self.P00.shape)
471
+ def get_js4_idx(self):
472
+ shape = list(self.S2.shape)
473
473
  nscale = shape[2]
474
474
  n = nscale * np.max([nscale - 1, 1]) * np.max([nscale - 2, 1])
475
475
  j1 = np.zeros([n * 4], dtype="int")
@@ -505,47 +505,47 @@ class scat_cov:
505
505
  else:
506
506
  s1 = self.S1 + other
507
507
 
508
- if self.C10 is None:
509
- c10 = None
508
+ if self.S3P is None:
509
+ s3p = None
510
510
  else:
511
511
  if isinstance(other, scat_cov):
512
- if other.C10 is None:
513
- c10 = None
512
+ if other.S3P is None:
513
+ s3p = None
514
514
  else:
515
- c10 = self.doadd(self.C10, other.C10)
515
+ s3p = self.doadd(self.S3P, other.S3P)
516
516
  else:
517
- c10 = self.C10 + other
517
+ s3p = self.S3P + other
518
518
 
519
- if self.C11 is None:
520
- c11 = None
519
+ if self.S4 is None:
520
+ s4 = None
521
521
  else:
522
522
  if isinstance(other, scat_cov):
523
- if other.C11 is None:
524
- c11 = None
523
+ if other.S4 is None:
524
+ s4 = None
525
525
  else:
526
- c11 = self.doadd(self.C11, other.C11)
526
+ s4 = self.doadd(self.S4, other.S4)
527
527
  else:
528
- c11 = self.C11 + other
528
+ s4 = self.S4 + other
529
529
 
530
530
  if isinstance(other, scat_cov):
531
531
  return scat_cov(
532
532
  self.doadd(self.S0, other.S0),
533
- self.doadd(self.P00, other.P00),
534
- (self.C01 + other.C01),
535
- c11,
533
+ self.doadd(self.S2, other.S2),
534
+ (self.S3 + other.S3),
535
+ s4,
536
536
  s1=s1,
537
- c10=c10,
537
+ s3p=s3p,
538
538
  backend=self.backend,
539
539
  use_1D=self.use_1D,
540
540
  )
541
541
  else:
542
542
  return scat_cov(
543
543
  (self.S0 + other),
544
- (self.P00 + other),
545
- (self.C01 + other),
546
- c11,
544
+ (self.S2 + other),
545
+ (self.S3 + other),
546
+ s4,
547
547
  s1=s1,
548
- c10=c10,
548
+ s3p=s3p,
549
549
  backend=self.backend,
550
550
  use_1D=self.use_1D,
551
551
  )
@@ -557,23 +557,23 @@ class scat_cov:
557
557
  else:
558
558
  s1 = self.backend.bk_relu(self.S1)
559
559
 
560
- if self.C10 is None:
561
- c10 = None
560
+ if self.S3P is None:
561
+ s3p = None
562
562
  else:
563
- c10 = self.backend.bk_relu(self.c10)
563
+ s3p = self.backend.bk_relu(self.s3p)
564
564
 
565
- if self.C11 is None:
566
- c11 = None
565
+ if self.S4 is None:
566
+ s4 = None
567
567
  else:
568
- c11 = self.backend.bk_relu(self.c11)
568
+ s4 = self.backend.bk_relu(self.s4)
569
569
 
570
570
  return scat_cov(
571
571
  self.backend.bk_relu(self.S0),
572
- self.backend.bk_relu(self.P00),
573
- self.backend.bk_relu(self.C01),
574
- c11,
572
+ self.backend.bk_relu(self.S2),
573
+ self.backend.bk_relu(self.S3),
574
+ s4,
575
575
  s1=s1,
576
- c10=c10,
576
+ s3p=s3p,
577
577
  backend=self.backend,
578
578
  use_1D=self.use_1D,
579
579
  )
@@ -601,47 +601,47 @@ class scat_cov:
601
601
  else:
602
602
  s1 = self.dodiv(self.S1, other)
603
603
 
604
- if self.C10 is None:
605
- c10 = None
604
+ if self.S3P is None:
605
+ s3p = None
606
606
  else:
607
607
  if isinstance(other, scat_cov):
608
- if other.C10 is None:
609
- c10 = None
608
+ if other.S3P is None:
609
+ s3p = None
610
610
  else:
611
- c10 = self.dodiv(self.C10, other.C10)
611
+ s3p = self.dodiv(self.S3P, other.S3P)
612
612
  else:
613
- c10 = self.dodiv(self.C10, other)
613
+ s3p = self.dodiv(self.S3P, other)
614
614
 
615
- if self.C11 is None:
616
- c11 = None
615
+ if self.S4 is None:
616
+ s4 = None
617
617
  else:
618
618
  if isinstance(other, scat_cov):
619
- if other.C11 is None:
620
- c11 = None
619
+ if other.S4 is None:
620
+ s4 = None
621
621
  else:
622
- c11 = self.dodiv(self.C11, other.C11)
622
+ s4 = self.dodiv(self.S4, other.S4)
623
623
  else:
624
- c11 = self.C11 / other
624
+ s4 = self.S4 / other
625
625
 
626
626
  if isinstance(other, scat_cov):
627
627
  return scat_cov(
628
628
  self.dodiv(self.S0, other.S0),
629
- self.dodiv(self.P00, other.P00),
630
- self.dodiv(self.C01, other.C01),
631
- c11,
629
+ self.dodiv(self.S2, other.S2),
630
+ self.dodiv(self.S3, other.S3),
631
+ s4,
632
632
  s1=s1,
633
- c10=c10,
633
+ s3p=s3p,
634
634
  backend=self.backend,
635
635
  use_1D=self.use_1D,
636
636
  )
637
637
  else:
638
638
  return scat_cov(
639
639
  (self.S0 / other),
640
- (self.P00 / other),
641
- (self.C01 / other),
642
- c11,
640
+ (self.S2 / other),
641
+ (self.S3 / other),
642
+ s4,
643
643
  s1=s1,
644
- c10=c10,
644
+ s3p=s3p,
645
645
  backend=self.backend,
646
646
  use_1D=self.use_1D,
647
647
  )
@@ -663,44 +663,44 @@ class scat_cov:
663
663
  else:
664
664
  s1 = other / self.S1
665
665
 
666
- if self.C10 is None:
667
- c10 = None
666
+ if self.S3P is None:
667
+ s3p = None
668
668
  else:
669
669
  if isinstance(other, scat_cov):
670
- c10 = self.dodiv(other.C10, self.C10)
670
+ s3p = self.dodiv(other.S3P, self.S3P)
671
671
  else:
672
- c10 = other / self.C10
672
+ s3p = other / self.S3P
673
673
 
674
- if self.C11 is None:
675
- c11 = None
674
+ if self.S4 is None:
675
+ s4 = None
676
676
  else:
677
677
  if isinstance(other, scat_cov):
678
- if other.C11 is None:
679
- c11 = None
678
+ if other.S4 is None:
679
+ s4 = None
680
680
  else:
681
- c11 = self.dodiv(other.C11, self.C11)
681
+ s4 = self.dodiv(other.S4, self.S4)
682
682
  else:
683
- c11 = other / self.C11
683
+ s4 = other / self.S4
684
684
 
685
685
  if isinstance(other, scat_cov):
686
686
  return scat_cov(
687
687
  self.dodiv(other.S0, self.S0),
688
- self.dodiv(other.P00, self.P00),
689
- (other.C01 / self.C01),
690
- c11,
688
+ self.dodiv(other.S2, self.S2),
689
+ (other.S3 / self.S3),
690
+ s4,
691
691
  s1=s1,
692
- c10=c10,
692
+ s3p=s3p,
693
693
  backend=self.backend,
694
694
  use_1D=self.use_1D,
695
695
  )
696
696
  else:
697
697
  return scat_cov(
698
698
  (other / self.S0),
699
- (other / self.P00),
700
- (other / self.C01),
701
- (other / self.C11),
699
+ (other / self.S2),
700
+ (other / self.S3),
701
+ (other / self.S4),
702
702
  s1=s1,
703
- c10=c10,
703
+ s3p=s3p,
704
704
  backend=self.backend,
705
705
  use_1D=self.use_1D,
706
706
  )
@@ -726,47 +726,47 @@ class scat_cov:
726
726
  else:
727
727
  s1 = other - self.S1
728
728
 
729
- if self.C10 is None:
730
- c10 = None
729
+ if self.S3P is None:
730
+ s3p = None
731
731
  else:
732
732
  if isinstance(other, scat_cov):
733
- if other.C10 is None:
734
- c10 = None
733
+ if other.S3P is None:
734
+ s3p = None
735
735
  else:
736
- c10 = self.domin(other.C10, self.C10)
736
+ s3p = self.domin(other.S3P, self.S3P)
737
737
  else:
738
- c10 = other - self.C10
738
+ s3p = other - self.S3P
739
739
 
740
- if self.C11 is None:
741
- c11 = None
740
+ if self.S4 is None:
741
+ s4 = None
742
742
  else:
743
743
  if isinstance(other, scat_cov):
744
- if other.C11 is None:
745
- c11 = None
744
+ if other.S4 is None:
745
+ s4 = None
746
746
  else:
747
- c11 = self.domin(other.C11, self.C11)
747
+ s4 = self.domin(other.S4, self.S4)
748
748
  else:
749
- c11 = other - self.C11
749
+ s4 = other - self.S4
750
750
 
751
751
  if isinstance(other, scat_cov):
752
752
  return scat_cov(
753
753
  self.domin(other.S0, self.S0),
754
- self.domin(other.P00, self.P00),
755
- (other.C01 - self.C01),
756
- c11,
754
+ self.domin(other.S2, self.S2),
755
+ (other.S3 - self.S3),
756
+ s4,
757
757
  s1=s1,
758
- c10=c10,
758
+ s3p=s3p,
759
759
  backend=self.backend,
760
760
  use_1D=self.use_1D,
761
761
  )
762
762
  else:
763
763
  return scat_cov(
764
764
  (other - self.S0),
765
- (other - self.P00),
766
- (other - self.C01),
767
- c11,
765
+ (other - self.S2),
766
+ (other - self.S3),
767
+ s4,
768
768
  s1=s1,
769
- c10=c10,
769
+ s3p=s3p,
770
770
  backend=self.backend,
771
771
  use_1D=self.use_1D,
772
772
  )
@@ -791,47 +791,47 @@ class scat_cov:
791
791
  else:
792
792
  s1 = self.S1 - other
793
793
 
794
- if self.C10 is None:
795
- c10 = None
794
+ if self.S3P is None:
795
+ s3p = None
796
796
  else:
797
797
  if isinstance(other, scat_cov):
798
- if other.C10 is None:
799
- c10 = None
798
+ if other.S3P is None:
799
+ s3p = None
800
800
  else:
801
- c10 = self.domin(self.C10, other.C10)
801
+ s3p = self.domin(self.S3P, other.S3P)
802
802
  else:
803
- c10 = self.C10 - other
803
+ s3p = self.S3P - other
804
804
 
805
- if self.C11 is None:
806
- c11 = None
805
+ if self.S4 is None:
806
+ s4 = None
807
807
  else:
808
808
  if isinstance(other, scat_cov):
809
- if other.C11 is None:
810
- c11 = None
809
+ if other.S4 is None:
810
+ s4 = None
811
811
  else:
812
- c11 = self.domin(self.C11, other.C11)
812
+ s4 = self.domin(self.S4, other.S4)
813
813
  else:
814
- c11 = self.C11 - other
814
+ s4 = self.S4 - other
815
815
 
816
816
  if isinstance(other, scat_cov):
817
817
  return scat_cov(
818
818
  self.domin(self.S0, other.S0),
819
- self.domin(self.P00, other.P00),
820
- (self.C01 - other.C01),
821
- c11,
819
+ self.domin(self.S2, other.S2),
820
+ (self.S3 - other.S3),
821
+ s4,
822
822
  s1=s1,
823
- c10=c10,
823
+ s3p=s3p,
824
824
  backend=self.backend,
825
825
  use_1D=self.use_1D,
826
826
  )
827
827
  else:
828
828
  return scat_cov(
829
829
  (self.S0 - other),
830
- (self.P00 - other),
831
- (self.C01 - other),
832
- c11,
830
+ (self.S2 - other),
831
+ (self.S3 - other),
832
+ s4,
833
833
  s1=s1,
834
- c10=c10,
834
+ s3p=s3p,
835
835
  backend=self.backend,
836
836
  use_1D=self.use_1D,
837
837
  )
@@ -921,47 +921,47 @@ class scat_cov:
921
921
  else:
922
922
  s1 = self.S1 * other
923
923
 
924
- if self.C10 is None:
925
- c10 = None
924
+ if self.S3P is None:
925
+ s3p = None
926
926
  else:
927
927
  if isinstance(other, scat_cov):
928
- if other.C10 is None:
929
- c10 = None
928
+ if other.S3P is None:
929
+ s3p = None
930
930
  else:
931
- c10 = self.domult(self.C10, other.C10)
931
+ s3p = self.domult(self.S3P, other.S3P)
932
932
  else:
933
- c10 = self.C10 * other
933
+ s3p = self.S3P * other
934
934
 
935
- if self.C11 is None:
936
- c11 = None
935
+ if self.S4 is None:
936
+ s4 = None
937
937
  else:
938
938
  if isinstance(other, scat_cov):
939
- if other.C11 is None:
940
- c11 = None
939
+ if other.S4 is None:
940
+ s4 = None
941
941
  else:
942
- c11 = self.domult(self.C11, other.C11)
942
+ s4 = self.domult(self.S4, other.S4)
943
943
  else:
944
- c11 = self.C11 * other
944
+ s4 = self.S4 * other
945
945
 
946
946
  if isinstance(other, scat_cov):
947
947
  return scat_cov(
948
948
  self.domult(self.S0, other.S0),
949
- self.domult(self.P00, other.P00),
950
- self.domult(self.C01, other.C01),
951
- c11,
949
+ self.domult(self.S2, other.S2),
950
+ self.domult(self.S3, other.S3),
951
+ s4,
952
952
  s1=s1,
953
- c10=c10,
953
+ s3p=s3p,
954
954
  backend=self.backend,
955
955
  use_1D=self.use_1D,
956
956
  )
957
957
  else:
958
958
  return scat_cov(
959
959
  (self.S0 * other),
960
- (self.P00 * other),
961
- (self.C01 * other),
962
- c11,
960
+ (self.S2 * other),
961
+ (self.S3 * other),
962
+ s4,
963
963
  s1=s1,
964
- c10=c10,
964
+ s3p=s3p,
965
965
  backend=self.backend,
966
966
  use_1D=self.use_1D,
967
967
  )
@@ -972,17 +972,17 @@ class scat_cov:
972
972
  # ---------------------------------------------−---------
973
973
  def interp(self, nscale, extend=True, constant=False):
974
974
 
975
- if nscale + 2 > self.P00.shape[2]:
975
+ if nscale + 2 > self.S2.shape[2]:
976
976
  print(
977
977
  "Can not *interp* %d with a statistic described over %d"
978
- % (nscale, self.P00.shape[2])
978
+ % (nscale, self.S2.shape[2])
979
979
  )
980
980
  return scat_cov(
981
- self.P00,
982
- self.C01,
983
- self.C11,
981
+ self.S2,
982
+ self.S3,
983
+ self.S4,
984
984
  s1=self.S1,
985
- c10=self.C10,
985
+ s3p=self.S3P,
986
986
  backend=self.backend,
987
987
  )
988
988
 
@@ -995,63 +995,67 @@ class scat_cov:
995
995
  s1 = self.S1
996
996
 
997
997
  if self.BACKEND == "numpy":
998
- p0 = self.P00
998
+ s2 = self.S2
999
999
  else:
1000
- p0 = self.P00.numpy()
1000
+ s2 = self.S2.numpy()
1001
1001
 
1002
1002
  for k in range(nscale):
1003
1003
  if constant:
1004
1004
  if self.S1 is not None:
1005
1005
  s1[:, :, nscale - 1 - k, :] = s1[:, :, nscale - k, :]
1006
- p0[:, :, nscale - 1 - k, :] = p0[:, :, nscale - k, :]
1006
+ s2[:, :, nscale - 1 - k, :] = s2[:, :, nscale - k, :]
1007
1007
  else:
1008
1008
  if self.S1 is not None:
1009
1009
  s1[:, :, nscale - 1 - k, :] = np.exp(
1010
1010
  2 * np.log(s1[:, :, nscale - k, :])
1011
1011
  - np.log(s1[:, :, nscale + 1 - k, :])
1012
1012
  )
1013
- p0[:, :, nscale - 1 - k, :] = np.exp(
1014
- 2 * np.log(p0[:, :, nscale - k, :])
1015
- - np.log(p0[:, :, nscale + 1 - k, :])
1013
+ s2[:, :, nscale - 1 - k, :] = np.exp(
1014
+ 2 * np.log(s2[:, :, nscale - k, :])
1015
+ - np.log(s2[:, :, nscale + 1 - k, :])
1016
1016
  )
1017
1017
 
1018
1018
  j1, j2 = self.get_j_idx()
1019
1019
 
1020
- if self.C10 is not None:
1020
+ if self.S3P is not None:
1021
1021
  if self.BACKEND == "numpy":
1022
- c10 = self.C10
1022
+ s3p = self.S3P
1023
1023
  else:
1024
- c10 = self.C10.numpy()
1024
+ s3p = self.S3P.numpy()
1025
1025
  else:
1026
- c10 = self.C10
1026
+ s3p = self.S3P
1027
1027
  if self.BACKEND == "numpy":
1028
- c01 = self.C01
1028
+ s3 = self.S3
1029
1029
  else:
1030
- c01 = self.C01.numpy()
1030
+ s3 = self.S3.numpy()
1031
1031
 
1032
1032
  for k in range(nscale):
1033
1033
 
1034
1034
  for l_orient in range(nscale - k):
1035
- i0 = np.where((j1 == nscale - 1 - k - l_orient) * (j2 == nscale - 1 - k))[0]
1035
+ i0 = np.where(
1036
+ (j1 == nscale - 1 - k - l_orient) * (j2 == nscale - 1 - k)
1037
+ )[0]
1036
1038
  i1 = np.where((j1 == nscale - 1 - k - l_orient) * (j2 == nscale - k))[0]
1037
- i2 = np.where((j1 == nscale - 1 - k - l_orient) * (j2 == nscale + 1 - k))[0]
1039
+ i2 = np.where(
1040
+ (j1 == nscale - 1 - k - l_orient) * (j2 == nscale + 1 - k)
1041
+ )[0]
1038
1042
  if constant:
1039
- c10[:, :, i0] = c10[:, :, i1]
1040
- c01[:, :, i0] = c01[:, :, i1]
1043
+ s3p[:, :, i0] = s3p[:, :, i1]
1044
+ s3[:, :, i0] = s3[:, :, i1]
1041
1045
  else:
1042
- c10[:, :, i0] = np.exp(
1043
- 2 * np.log(c10[:, :, i1]) - np.log(c10[:, :, i2])
1046
+ s3p[:, :, i0] = np.exp(
1047
+ 2 * np.log(s3p[:, :, i1]) - np.log(s3p[:, :, i2])
1044
1048
  )
1045
- c01[:, :, i0] = np.exp(
1046
- 2 * np.log(c01[:, :, i1]) - np.log(c01[:, :, i2])
1049
+ s3[:, :, i0] = np.exp(
1050
+ 2 * np.log(s3[:, :, i1]) - np.log(s3[:, :, i2])
1047
1051
  )
1048
1052
 
1049
1053
  if self.BACKEND == "numpy":
1050
- c11 = self.C11
1054
+ s4 = self.S4
1051
1055
  else:
1052
- c11 = self.C11.numpy()
1056
+ s4 = self.S4.numpy()
1053
1057
 
1054
- j1, j2, j3 = self.get_jc11_idx()
1058
+ j1, j2, j3 = self.get_js4_idx()
1055
1059
 
1056
1060
  for k in range(nscale):
1057
1061
 
@@ -1073,24 +1077,24 @@ class scat_cov:
1073
1077
  * (j3 == nscale + 1 - k)
1074
1078
  )[0]
1075
1079
  if constant:
1076
- c11[:, :, i0] = c11[:, :, i1]
1080
+ s4[:, :, i0] = s4[:, :, i1]
1077
1081
  else:
1078
- c11[:, :, i0] = np.exp(
1079
- 2 * np.log(c11[:, :, i1]) - np.log(c11[:, :, i2])
1082
+ s4[:, :, i0] = np.exp(
1083
+ 2 * np.log(s4[:, :, i1]) - np.log(s4[:, :, i2])
1080
1084
  )
1081
1085
 
1082
1086
  if s1 is not None:
1083
1087
  s1 = self.backend.constant(s1)
1084
- if c10 is not None:
1085
- c10 = self.backend.constant(c10)
1088
+ if s3p is not None:
1089
+ s3p = self.backend.constant(s3p)
1086
1090
 
1087
1091
  return scat_cov(
1088
1092
  self.S0,
1089
- self.backend.constant(p0),
1090
- self.backend.constant(c01),
1091
- self.backend.constant(c11),
1093
+ self.backend.constant(s2),
1094
+ self.backend.constant(s3),
1095
+ self.backend.constant(s4),
1092
1096
  s1=s1,
1093
- c10=c10,
1097
+ s3p=s3p,
1094
1098
  backend=self.backend,
1095
1099
  use_1D=self.use_1D,
1096
1100
  )
@@ -1109,7 +1113,7 @@ class scat_cov:
1109
1113
 
1110
1114
  test = None
1111
1115
  plt.subplot(2, 2, 2)
1112
- tmp = abs(self.get_np(self.P00))
1116
+ tmp = abs(self.get_np(self.S2))
1113
1117
  ntmp = np.sqrt(tmp)
1114
1118
  if len(tmp.shape) > 3:
1115
1119
  for k in range(tmp.shape[3]):
@@ -1120,7 +1124,7 @@ class scat_cov:
1120
1124
  plt.plot(
1121
1125
  tmp[i1, i2, :, k],
1122
1126
  color=color,
1123
- label=r"%s $P_{00}$" % (name),
1127
+ label=r"%s $S_2$" % (name),
1124
1128
  lw=lw,
1125
1129
  )
1126
1130
  else:
@@ -1133,15 +1137,15 @@ class scat_cov:
1133
1137
  plt.plot(
1134
1138
  tmp[i1, i2, :],
1135
1139
  color=color,
1136
- label=r"%s $P_{00}$" % (name),
1140
+ label=r"%s $S_2$" % (name),
1137
1141
  lw=lw,
1138
1142
  )
1139
1143
  else:
1140
1144
  plt.plot(tmp[i1, i2, :], color=color, lw=lw)
1141
1145
  plt.yscale("log")
1142
- plt.ylabel("P00")
1146
+ plt.ylabel("$S_2$")
1143
1147
  plt.xlabel(r"$j_{1}$")
1144
- plt.legend()
1148
+ plt.legend(frameon=0)
1145
1149
 
1146
1150
  if self.S1 is not None:
1147
1151
  plt.subplot(2, 2, 1)
@@ -1196,9 +1200,9 @@ class scat_cov:
1196
1200
  else:
1197
1201
  plt.plot(tmp[i1, i2, :], color=color, lw=lw)
1198
1202
  plt.yscale("log")
1199
- plt.legend()
1203
+ plt.legend(frameon=0)
1200
1204
  if norm:
1201
- plt.ylabel(r"$\frac{S_1}{\sqrt{P_{00}}}$")
1205
+ plt.ylabel(r"$\frac{S_1}{\sqrt{S_2}}$")
1202
1206
  else:
1203
1207
  plt.ylabel("$S_1$")
1204
1208
  plt.xlabel(r"$j_{1}$")
@@ -1206,22 +1210,22 @@ class scat_cov:
1206
1210
  ax1 = plt.subplot(2, 2, 3)
1207
1211
  ax2 = ax1.twiny()
1208
1212
  n = 0
1209
- tmp = abs(self.get_np(self.C01))
1213
+ tmp = abs(self.get_np(self.S3))
1210
1214
  if norm:
1211
- lname = r"%s norm. $C_{01}$" % (name)
1212
- ax1.set_ylabel(r"$\frac{C_{01}}{\sqrt{P_{00,j_1}P_{00,j_2}}}$")
1215
+ lname = r"%s norm. $S_{3}$" % (name)
1216
+ ax1.set_ylabel(r"$\frac{S_3}{\sqrt{S_{2,j_1}S_{2,j_2}}}$")
1213
1217
  else:
1214
- lname = r"%s $C_{01}$" % (name)
1215
- ax1.set_ylabel(r"$C_{01}$")
1218
+ lname = r"%s $S_3$" % (name)
1219
+ ax1.set_ylabel(r"$S_3$")
1216
1220
 
1217
- if self.C10 is not None:
1218
- tmp = abs(self.get_np(self.C01))
1221
+ if self.S3P is not None:
1222
+ tmp = abs(self.get_np(self.S3))
1219
1223
  if norm:
1220
- lname = r"%s norm. $C_{10}$" % (name)
1221
- ax1.set_ylabel(r"$\frac{C_{10}}{\sqrt{P_{00,j_1}P_{00,j_2}}}$")
1224
+ lname = r"%s norm. $\tilde{S}_{3}$" % (name)
1225
+ ax1.set_ylabel(r"$\frac{\tilde{S}_{3}}{\sqrt{S_{2,j_1}S_{2,j_2}}}$")
1222
1226
  else:
1223
- lname = r"%s $C_{10}$" % (name)
1224
- ax1.set_ylabel(r"$C_{10}$")
1227
+ lname = r"%s $\tilde{S}_{3}$" % (name)
1228
+ ax1.set_ylabel(r"$\tilde{S}_{3}$")
1225
1229
 
1226
1230
  test = None
1227
1231
  tabx = []
@@ -1355,11 +1359,11 @@ class scat_cov:
1355
1359
  ax1.legend(frameon=0)
1356
1360
 
1357
1361
  ax1 = plt.subplot(2, 2, 4)
1358
- j1, j2, j3 = self.get_jc11_idx()
1362
+ j1, j2, j3 = self.get_js4_idx()
1359
1363
  ax2 = ax1.twiny()
1360
1364
  n = 1
1361
- tmp = abs(self.get_np(self.C11))
1362
- lname = r"%s $C_{11}$" % (name)
1365
+ tmp = abs(self.get_np(self.S4))
1366
+ lname = r"%s $S_4$" % (name)
1363
1367
  test = None
1364
1368
  tabx = []
1365
1369
  tabnx = []
@@ -1492,9 +1496,9 @@ class scat_cov:
1492
1496
  ax1.axvline(n - 0.5, ls=":", color="gray")
1493
1497
  plt.yscale("log")
1494
1498
  if norm:
1495
- ax1.set_ylabel(r"$\frac{C_{11}}{\sqrt{P_{00,j_1}P_{00,j_2}}}$")
1499
+ ax1.set_ylabel(r"$\frac{S_4}{\sqrt{S_{2,j_1}S_{2,j_2}}}$")
1496
1500
  else:
1497
- ax1.set_ylabel(r"$C_{11}$")
1501
+ ax1.set_ylabel(r"$S_4$")
1498
1502
 
1499
1503
  ax1.set_xticks(tabx)
1500
1504
  ax1.set_xticklabels(tabnx, fontsize=6)
@@ -1536,10 +1540,10 @@ class scat_cov:
1536
1540
  outlist = [
1537
1541
  self.get_np(self.S0),
1538
1542
  self.get_np(self.S1),
1539
- self.get_np(self.C10),
1540
- self.get_np(self.C01),
1541
- self.get_np(self.C11),
1542
- self.get_np(self.P00),
1543
+ self.get_np(self.S3P),
1544
+ self.get_np(self.S3),
1545
+ self.get_np(self.S4),
1546
+ self.get_np(self.S2),
1543
1547
  ]
1544
1548
 
1545
1549
  myout = open("%s.pkl" % (filename), "wb")
@@ -1556,7 +1560,7 @@ class scat_cov:
1556
1560
  outlist[3],
1557
1561
  outlist[4],
1558
1562
  s1=outlist[1],
1559
- c10=outlist[2],
1563
+ s3p=outlist[2],
1560
1564
  backend=self.backend,
1561
1565
  use_1D=self.use_1D,
1562
1566
  )
@@ -1567,9 +1571,9 @@ class scat_cov:
1567
1571
  (
1568
1572
  (abs(self.get_np(self.S0)).std()) ** 2
1569
1573
  + (abs(self.get_np(self.S1)).std()) ** 2
1570
- + (abs(self.get_np(self.C01)).std()) ** 2
1571
- + (abs(self.get_np(self.C11)).std()) ** 2
1572
- + (abs(self.get_np(self.P00)).std()) ** 2
1574
+ + (abs(self.get_np(self.S3)).std()) ** 2
1575
+ + (abs(self.get_np(self.S4)).std()) ** 2
1576
+ + (abs(self.get_np(self.S2)).std()) ** 2
1573
1577
  )
1574
1578
  / 4
1575
1579
  )
@@ -1577,10 +1581,10 @@ class scat_cov:
1577
1581
  return np.sqrt(
1578
1582
  (
1579
1583
  (abs(self.get_np(self.S0)).std()) ** 2
1580
- + (abs(self.get_np(self.C01)).std()) ** 2
1581
- + (abs(self.get_np(self.C10)).std()) ** 2
1582
- + (abs(self.get_np(self.C11)).std()) ** 2
1583
- + (abs(self.get_np(self.P00)).std()) ** 2
1584
+ + (abs(self.get_np(self.S3)).std()) ** 2
1585
+ + (abs(self.get_np(self.S3P)).std()) ** 2
1586
+ + (abs(self.get_np(self.S4)).std()) ** 2
1587
+ + (abs(self.get_np(self.S2)).std()) ** 2
1584
1588
  )
1585
1589
  / 4
1586
1590
  )
@@ -1590,17 +1594,17 @@ class scat_cov:
1590
1594
  return (
1591
1595
  abs(self.get_np(self.S0)).mean()
1592
1596
  + abs(self.get_np(self.S1)).mean()
1593
- + abs(self.get_np(self.C01)).mean()
1594
- + abs(self.get_np(self.C11)).mean()
1595
- + abs(self.get_np(self.P00)).mean()
1597
+ + abs(self.get_np(self.S3)).mean()
1598
+ + abs(self.get_np(self.S4)).mean()
1599
+ + abs(self.get_np(self.S2)).mean()
1596
1600
  ) / 4
1597
1601
  else: # Cross
1598
1602
  return (
1599
1603
  abs(self.get_np(self.S0)).mean()
1600
- + abs(self.get_np(self.C01)).mean()
1601
- + abs(self.get_np(self.C10)).mean()
1602
- + abs(self.get_np(self.C11)).mean()
1603
- + abs(self.get_np(self.P00)).mean()
1604
+ + abs(self.get_np(self.S3)).mean()
1605
+ + abs(self.get_np(self.S3P)).mean()
1606
+ + abs(self.get_np(self.S4)).mean()
1607
+ + abs(self.get_np(self.S2)).mean()
1604
1608
  ) / 4
1605
1609
 
1606
1610
  def initdx(self, norient):
@@ -1628,62 +1632,62 @@ class scat_cov:
1628
1632
  def sqrt(self):
1629
1633
 
1630
1634
  s1 = None
1631
- c10 = None
1635
+ s3p = None
1632
1636
 
1633
1637
  if self.S1 is not None:
1634
1638
  s1 = self.backend.bk_sqrt(self.S1)
1635
- if self.C10 is not None:
1636
- c10 = self.backend.bk_sqrt(self.C10)
1639
+ if self.S3P is not None:
1640
+ s3p = self.backend.bk_sqrt(self.S3P)
1637
1641
 
1638
1642
  s0 = self.backend.bk_sqrt(self.S0)
1639
- p00 = self.backend.bk_sqrt(self.P00)
1640
- c01 = self.backend.bk_sqrt(self.C01)
1641
- c11 = self.backend.bk_sqrt(self.C11)
1643
+ s2 = self.backend.bk_sqrt(self.S2)
1644
+ s3 = self.backend.bk_sqrt(self.S3)
1645
+ s4 = self.backend.bk_sqrt(self.S4)
1642
1646
 
1643
1647
  return scat_cov(
1644
- s0, p00, c01, c11, s1=s1, c10=c10, backend=self.backend, use_1D=self.use_1D
1648
+ s0, s2, s3, s4, s1=s1, s3p=s3p, backend=self.backend, use_1D=self.use_1D
1645
1649
  )
1646
1650
 
1647
1651
  def L1(self):
1648
1652
 
1649
1653
  s1 = None
1650
- c10 = None
1654
+ s3p = None
1651
1655
 
1652
1656
  if self.S1 is not None:
1653
1657
  s1 = self.backend.bk_L1(self.S1)
1654
- if self.C10 is not None:
1655
- c10 = self.backend.bk_L1(self.C10)
1658
+ if self.S3P is not None:
1659
+ s3p = self.backend.bk_L1(self.S3P)
1656
1660
 
1657
1661
  s0 = self.backend.bk_L1(self.S0)
1658
- p00 = self.backend.bk_L1(self.P00)
1659
- c01 = self.backend.bk_L1(self.C01)
1660
- c11 = self.backend.bk_L1(self.C11)
1662
+ s2 = self.backend.bk_L1(self.S2)
1663
+ s3 = self.backend.bk_L1(self.S3)
1664
+ s4 = self.backend.bk_L1(self.S4)
1661
1665
 
1662
1666
  return scat_cov(
1663
- s0, p00, c01, c11, s1=s1, c10=c10, backend=self.backend, use_1D=self.use_1D
1667
+ s0, s2, s3, s4, s1=s1, s3p=s3p, backend=self.backend, use_1D=self.use_1D
1664
1668
  )
1665
1669
 
1666
1670
  def square_comp(self):
1667
1671
 
1668
1672
  s1 = None
1669
- c10 = None
1673
+ s3p = None
1670
1674
 
1671
1675
  if self.S1 is not None:
1672
1676
  s1 = self.backend.bk_square_comp(self.S1)
1673
- if self.C10 is not None:
1674
- c10 = self.backend.bk_square_comp(self.C10)
1677
+ if self.S3P is not None:
1678
+ s3p = self.backend.bk_square_comp(self.S3P)
1675
1679
 
1676
1680
  s0 = self.backend.bk_square_comp(self.S0)
1677
- p00 = self.backend.bk_square_comp(self.P00)
1678
- c01 = self.backend.bk_square_comp(self.C01)
1679
- c11 = self.backend.bk_square_comp(self.C11)
1681
+ s2 = self.backend.bk_square_comp(self.S2)
1682
+ s3 = self.backend.bk_square_comp(self.S3)
1683
+ s4 = self.backend.bk_square_comp(self.S4)
1680
1684
 
1681
1685
  return scat_cov(
1682
- s0, p00, c01, c11, s1=s1, c10=c10, backend=self.backend, use_1D=self.use_1D
1686
+ s0, s2, s3, s4, s1=s1, s3p=s3p, backend=self.backend, use_1D=self.use_1D
1683
1687
  )
1684
1688
 
1685
1689
  def iso_mean(self, repeat=False):
1686
- shape = list(self.P00.shape)
1690
+ shape = list(self.S2.shape)
1687
1691
  norient = shape[3]
1688
1692
 
1689
1693
  S1 = self.S1
@@ -1693,125 +1697,125 @@ class scat_cov:
1693
1697
  S1 = self.backend.bk_reshape(
1694
1698
  self.backend.bk_repeat(S1, norient, 2), self.S1.shape
1695
1699
  )
1696
- P00 = self.backend.bk_reduce_mean(self.P00, 3)
1700
+ S2 = self.backend.bk_reduce_mean(self.S2, 3)
1697
1701
  if repeat:
1698
- P00 = self.backend.bk_reshape(
1699
- self.backend.bk_repeat(P00, norient, 2), self.P00.shape
1702
+ S2 = self.backend.bk_reshape(
1703
+ self.backend.bk_repeat(S2, norient, 2), self.S2.shape
1700
1704
  )
1701
1705
 
1702
- C01 = self.C01
1706
+ S3 = self.S3
1703
1707
 
1704
1708
  if norient not in self.backend._iso_orient:
1705
1709
  self.backend.calc_iso_orient(norient)
1706
1710
 
1707
- shape = list(self.C01.shape)
1708
- if self.C01 is not None:
1709
- if self.backend.bk_is_complex(self.C01):
1711
+ shape = list(self.S3.shape)
1712
+ if self.S3 is not None:
1713
+ if self.backend.bk_is_complex(self.S3):
1710
1714
  lmat = self.backend._iso_orient_C[norient]
1711
1715
  lmat_T = self.backend._iso_orient_C_T[norient]
1712
1716
  else:
1713
1717
  lmat = self.backend._iso_orient[norient]
1714
1718
  lmat_T = self.backend._iso_orient_T[norient]
1715
1719
 
1716
- C01 = self.backend.bk_reshape(
1720
+ S3 = self.backend.bk_reshape(
1717
1721
  self.backend.backend.matmul(
1718
1722
  self.backend.bk_reshape(
1719
- self.C01, [shape[0] * shape[1] * shape[2], norient * norient]
1723
+ self.S3, [shape[0] * shape[1] * shape[2], norient * norient]
1720
1724
  ),
1721
1725
  lmat,
1722
1726
  ),
1723
1727
  [shape[0], shape[1], shape[2], norient],
1724
1728
  )
1725
1729
  if repeat:
1726
- C01 = self.backend.bk_reshape(
1730
+ S3 = self.backend.bk_reshape(
1727
1731
  self.backend.backend.matmul(
1728
1732
  self.backend.bk_reshape(
1729
- C01, [shape[0] * shape[1] * shape[2], norient]
1733
+ S3, [shape[0] * shape[1] * shape[2], norient]
1730
1734
  ),
1731
1735
  lmat_T,
1732
1736
  ),
1733
1737
  [shape[0], shape[1], shape[2], norient, norient],
1734
1738
  )
1735
1739
 
1736
- C10 = self.C10
1737
- if self.C10 is not None:
1738
- if self.backend.bk_is_complex(self.C10):
1740
+ S3P = self.S3P
1741
+ if self.S3P is not None:
1742
+ if self.backend.bk_is_complex(self.S3P):
1739
1743
  lmat = self.backend._iso_orient_C[norient]
1740
1744
  lmat_T = self.backend._iso_orient_C_T[norient]
1741
1745
  else:
1742
1746
  lmat = self.backend._iso_orient[norient]
1743
1747
  lmat_T = self.backend._iso_orient_T[norient]
1744
1748
 
1745
- C10 = self.backend.bk_reshape(
1749
+ S3P = self.backend.bk_reshape(
1746
1750
  self.backend.backend.matmul(
1747
1751
  self.backend.bk_reshape(
1748
- self.C10, [shape[0] * shape[1] * shape[2], norient * norient]
1752
+ self.S3P, [shape[0] * shape[1] * shape[2], norient * norient]
1749
1753
  ),
1750
1754
  lmat,
1751
1755
  ),
1752
1756
  [shape[0], shape[1], shape[2], norient],
1753
1757
  )
1754
1758
  if repeat:
1755
- C10 = self.backend.bk_reshape(
1759
+ S3P = self.backend.bk_reshape(
1756
1760
  self.backend.backend.matmul(
1757
1761
  self.backend.bk_reshape(
1758
- C10, [shape[0] * shape[1] * shape[2], norient]
1762
+ S3P, [shape[0] * shape[1] * shape[2], norient]
1759
1763
  ),
1760
1764
  lmat_T,
1761
1765
  ),
1762
1766
  [shape[0], shape[1], shape[2], norient, norient],
1763
1767
  )
1764
1768
 
1765
- C11 = self.C11
1766
- if self.C11 is not None:
1767
- if self.backend.bk_is_complex(self.C11):
1769
+ S4 = self.S4
1770
+ if self.S4 is not None:
1771
+ if self.backend.bk_is_complex(self.S4):
1768
1772
  lmat = self.backend._iso_orient_C[norient]
1769
1773
  lmat_T = self.backend._iso_orient_C_T[norient]
1770
1774
  else:
1771
1775
  lmat = self.backend._iso_orient[norient]
1772
1776
  lmat_T = self.backend._iso_orient_T[norient]
1773
1777
 
1774
- shape = list(self.C11.shape)
1775
- C11 = self.backend.bk_reshape(
1778
+ shape = list(self.S4.shape)
1779
+ S4 = self.backend.bk_reshape(
1776
1780
  self.backend.backend.matmul(
1777
1781
  self.backend.bk_reshape(
1778
- self.C11,
1782
+ self.S4,
1779
1783
  [shape[0] * shape[1] * shape[2] * norient, norient * norient],
1780
1784
  ),
1781
1785
  lmat,
1782
1786
  ),
1783
1787
  [shape[0], shape[1], shape[2], norient, norient],
1784
1788
  )
1785
- C11 = self.backend.bk_reduce_mean(C11, 3)
1789
+ S4 = self.backend.bk_reduce_mean(S4, 3)
1786
1790
  if repeat:
1787
- C11 = self.backend.bk_reshape(
1791
+ S4 = self.backend.bk_reshape(
1788
1792
  self.backend.bk_repeat(
1789
1793
  self.backend.bk_reshape(
1790
- C11, [shape[0] * shape[1] * shape[2], norient]
1794
+ S4, [shape[0] * shape[1] * shape[2], norient]
1791
1795
  ),
1792
1796
  norient,
1793
1797
  axis=0,
1794
1798
  ),
1795
1799
  [shape[0] * shape[1] * shape[2] * norient, norient],
1796
1800
  )
1797
- C11 = self.backend.bk_reshape(
1798
- self.backend.backend.matmul(C11, lmat_T),
1801
+ S4 = self.backend.bk_reshape(
1802
+ self.backend.backend.matmul(S4, lmat_T),
1799
1803
  [shape[0], shape[1], shape[2], norient, norient, norient],
1800
1804
  )
1801
1805
 
1802
1806
  return scat_cov(
1803
1807
  self.S0,
1804
- P00,
1805
- C01,
1806
- C11,
1808
+ S2,
1809
+ S3,
1810
+ S4,
1807
1811
  s1=S1,
1808
- c10=C10,
1812
+ s3p=S3P,
1809
1813
  backend=self.backend,
1810
1814
  use_1D=self.use_1D,
1811
1815
  )
1812
1816
 
1813
1817
  def fft_ang(self, nharm=1, imaginary=False):
1814
- shape = list(self.P00.shape)
1818
+ shape = list(self.S2.shape)
1815
1819
  norient = shape[3]
1816
1820
 
1817
1821
  if (norient, nharm) not in self.backend._fft_1_orient:
@@ -1837,68 +1841,68 @@ class scat_cov:
1837
1841
  [shape[0], shape[1], shape[2], nout],
1838
1842
  )
1839
1843
 
1840
- if self.backend.bk_is_complex(self.P00):
1844
+ if self.backend.bk_is_complex(self.S2):
1841
1845
  lmat = self.backend._fft_1_orient_C[(norient, nharm, imaginary)]
1842
1846
  else:
1843
1847
  lmat = self.backend._fft_1_orient[(norient, nharm, imaginary)]
1844
1848
 
1845
- P00 = self.backend.bk_reshape(
1849
+ S2 = self.backend.bk_reshape(
1846
1850
  self.backend.backend.matmul(
1847
1851
  self.backend.bk_reshape(
1848
- self.P00, [shape[0] * shape[1] * shape[2], norient]
1852
+ self.S2, [shape[0] * shape[1] * shape[2], norient]
1849
1853
  ),
1850
1854
  lmat,
1851
1855
  ),
1852
1856
  [shape[0], shape[1], shape[2], nout],
1853
1857
  )
1854
1858
 
1855
- C01 = self.C01
1856
- shape = list(self.C01.shape)
1857
- if self.C01 is not None:
1858
- if self.backend.bk_is_complex(self.C01):
1859
+ S3 = self.S3
1860
+ shape = list(self.S3.shape)
1861
+ if self.S3 is not None:
1862
+ if self.backend.bk_is_complex(self.S3):
1859
1863
  lmat = self.backend._fft_2_orient_C[(norient, nharm, imaginary)]
1860
1864
  else:
1861
1865
  lmat = self.backend._fft_2_orient[(norient, nharm, imaginary)]
1862
1866
 
1863
- C01 = self.backend.bk_reshape(
1867
+ S3 = self.backend.bk_reshape(
1864
1868
  self.backend.backend.matmul(
1865
1869
  self.backend.bk_reshape(
1866
- self.C01, [shape[0] * shape[1] * shape[2], norient * norient]
1870
+ self.S3, [shape[0] * shape[1] * shape[2], norient * norient]
1867
1871
  ),
1868
1872
  lmat,
1869
1873
  ),
1870
1874
  [shape[0], shape[1], shape[2], nout, nout],
1871
1875
  )
1872
1876
 
1873
- C10 = self.C10
1874
- if self.C10 is not None:
1875
- if self.backend.bk_is_complex(self.C10):
1877
+ S3P = self.S3P
1878
+ if self.S3P is not None:
1879
+ if self.backend.bk_is_complex(self.S3P):
1876
1880
  lmat = self.backend._fft_2_orient_C[(norient, nharm, imaginary)]
1877
1881
  else:
1878
1882
  lmat = self.backend._fft_2_orient[(norient, nharm, imaginary)]
1879
1883
 
1880
- C10 = self.backend.bk_reshape(
1884
+ S3P = self.backend.bk_reshape(
1881
1885
  self.backend.backend.matmul(
1882
1886
  self.backend.bk_reshape(
1883
- self.C10, [shape[0] * shape[1] * shape[2], norient * norient]
1887
+ self.S3P, [shape[0] * shape[1] * shape[2], norient * norient]
1884
1888
  ),
1885
1889
  lmat,
1886
1890
  ),
1887
1891
  [shape[0], shape[1], shape[2], nout, nout],
1888
1892
  )
1889
1893
 
1890
- C11 = self.C11
1891
- if self.C11 is not None:
1892
- if self.backend.bk_is_complex(self.C01):
1894
+ S4 = self.S4
1895
+ if self.S4 is not None:
1896
+ if self.backend.bk_is_complex(self.S3):
1893
1897
  lmat = self.backend._fft_3_orient_C[(norient, nharm, imaginary)]
1894
1898
  else:
1895
1899
  lmat = self.backend._fft_3_orient[(norient, nharm, imaginary)]
1896
1900
 
1897
- shape = list(self.C11.shape)
1898
- C11 = self.backend.bk_reshape(
1901
+ shape = list(self.S4.shape)
1902
+ S4 = self.backend.bk_reshape(
1899
1903
  self.backend.backend.matmul(
1900
1904
  self.backend.bk_reshape(
1901
- self.C11,
1905
+ self.S4,
1902
1906
  [shape[0] * shape[1] * shape[2], norient * norient * norient],
1903
1907
  ),
1904
1908
  lmat,
@@ -1908,11 +1912,11 @@ class scat_cov:
1908
1912
 
1909
1913
  return scat_cov(
1910
1914
  self.S0,
1911
- P00,
1912
- C01,
1913
- C11,
1915
+ S2,
1916
+ S3,
1917
+ S4,
1914
1918
  s1=S1,
1915
- c10=C10,
1919
+ s3p=S3P,
1916
1920
  backend=self.backend,
1917
1921
  use_1D=self.use_1D,
1918
1922
  )
@@ -1923,10 +1927,10 @@ class scat_cov:
1923
1927
  return (val.iso_mean(repeat=repeat)).L1()
1924
1928
 
1925
1929
  def get_nscale(self):
1926
- return self.P00.shape[2]
1930
+ return self.S2.shape[2]
1927
1931
 
1928
1932
  def get_norient(self):
1929
- return self.P00.shape[3]
1933
+ return self.S2.shape[3]
1930
1934
 
1931
1935
  def add_data_from_log_slope(self, y, n, ds=3):
1932
1936
  if len(y) < ds:
@@ -1949,33 +1953,33 @@ class scat_cov:
1949
1953
  return (np.arange(n) - 1 - n) * a[0] + a[1]
1950
1954
 
1951
1955
  def up_grade(self, nscale, ds=3):
1952
- noff = nscale - self.P00.shape[2]
1956
+ noff = nscale - self.S2.shape[2]
1953
1957
  if noff == 0:
1954
1958
  return scat_cov(
1955
1959
  (self.S0),
1956
- (self.P00),
1957
- (self.C01),
1958
- (self.C11),
1960
+ (self.S2),
1961
+ (self.S3),
1962
+ (self.S4),
1959
1963
  s1=self.S1,
1960
- c10=self.C10,
1964
+ s3p=self.S3P,
1961
1965
  backend=self.backend,
1962
1966
  use_1D=self.use_1D,
1963
1967
  )
1964
1968
 
1965
- inscale = self.P00.shape[2]
1966
- p00 = np.zeros(
1967
- [self.P00.shape[0], self.P00.shape[1], nscale, self.P00.shape[3]],
1969
+ inscale = self.S2.shape[2]
1970
+ s2 = np.zeros(
1971
+ [self.S2.shape[0], self.S2.shape[1], nscale, self.S2.shape[3]],
1968
1972
  dtype="complex",
1969
1973
  )
1970
1974
  if self.BACKEND == "numpy":
1971
- p00[:, :, noff:, :] = self.P00
1972
- else:
1973
- p00[:, :, noff:, :] = self.P00.numpy()
1974
- for i in range(self.P00.shape[0]):
1975
- for j in range(self.P00.shape[1]):
1976
- for k in range(self.P00.shape[3]):
1977
- p00[i, j, 0:noff, k] = self.add_data_from_log_slope(
1978
- p00[i, j, noff:, k], noff, ds=ds
1975
+ s2[:, :, noff:, :] = self.S2
1976
+ else:
1977
+ s2[:, :, noff:, :] = self.S2.numpy()
1978
+ for i in range(self.S2.shape[0]):
1979
+ for j in range(self.S2.shape[1]):
1980
+ for k in range(self.S2.shape[3]):
1981
+ s2[i, j, 0:noff, k] = self.add_data_from_log_slope(
1982
+ s2[i, j, noff:, k], noff, ds=ds
1979
1983
  )
1980
1984
 
1981
1985
  s1 = np.zeros([self.S1.shape[0], self.S1.shape[1], nscale, self.S1.shape[3]])
@@ -1994,13 +1998,13 @@ class scat_cov:
1994
1998
  for i in range(1, nscale):
1995
1999
  nout = nout + i
1996
2000
 
1997
- c01 = np.zeros(
2001
+ s3 = np.zeros(
1998
2002
  [
1999
- self.C01.shape[0],
2000
- self.C01.shape[1],
2003
+ self.S3.shape[0],
2004
+ self.S3.shape[1],
2001
2005
  nout,
2002
- self.C01.shape[3],
2003
- self.C01.shape[4],
2006
+ self.S3.shape[3],
2007
+ self.S3.shape[4],
2004
2008
  ],
2005
2009
  dtype="complex",
2006
2010
  )
@@ -2014,47 +2018,57 @@ class scat_cov:
2014
2018
  jo2[n : n + i] = i
2015
2019
  n = n + i
2016
2020
 
2017
- j1 = np.zeros([self.C01.shape[2]])
2018
- j2 = np.zeros([self.C01.shape[2]])
2021
+ j1 = np.zeros([self.S3.shape[2]])
2022
+ j2 = np.zeros([self.S3.shape[2]])
2019
2023
 
2020
2024
  n = 0
2021
- for i in range(1, self.P00.shape[2]):
2025
+ for i in range(1, self.S2.shape[2]):
2022
2026
  j1[n : n + i] = np.arange(i)
2023
2027
  j2[n : n + i] = i
2024
2028
  n = n + i
2025
2029
 
2026
- for i in range(self.C01.shape[0]):
2027
- for j in range(self.C01.shape[1]):
2028
- for k in range(self.C01.shape[3]):
2029
- for l_orient in range(self.C01.shape[4]):
2030
+ for i in range(self.S3.shape[0]):
2031
+ for j in range(self.S3.shape[1]):
2032
+ for k in range(self.S3.shape[3]):
2033
+ for l_orient in range(self.S3.shape[4]):
2030
2034
  for ij in range(noff + 1, nscale):
2031
2035
  idx = np.where(jo2 == ij)[0]
2032
2036
  if self.BACKEND == "numpy":
2033
- c01[i, j, idx[noff:], k, l_orient] = self.C01[
2037
+ s3[i, j, idx[noff:], k, l_orient] = self.S3[
2034
2038
  i, j, j2 == ij - noff, k, l_orient
2035
2039
  ]
2036
- c01[i, j, idx[:noff], k, l_orient] = self.add_data_from_slope(
2037
- self.C01[i, j, j2 == ij - noff, k, l_orient], noff, ds=ds
2040
+ s3[i, j, idx[:noff], k, l_orient] = (
2041
+ self.add_data_from_slope(
2042
+ self.S3[i, j, j2 == ij - noff, k, l_orient],
2043
+ noff,
2044
+ ds=ds,
2045
+ )
2038
2046
  )
2039
2047
  else:
2040
- c01[i, j, idx[noff:], k, l_orient] = self.C01.numpy()[
2048
+ s3[i, j, idx[noff:], k, l_orient] = self.S3.numpy()[
2041
2049
  i, j, j2 == ij - noff, k, l_orient
2042
2050
  ]
2043
- c01[i, j, idx[:noff], k, l_orient] = self.add_data_from_slope(
2044
- self.C01.numpy()[i, j, j2 == ij - noff, k, l_orient],
2045
- noff,
2046
- ds=ds,
2051
+ s3[i, j, idx[:noff], k, l_orient] = (
2052
+ self.add_data_from_slope(
2053
+ self.S3.numpy()[
2054
+ i, j, j2 == ij - noff, k, l_orient
2055
+ ],
2056
+ noff,
2057
+ ds=ds,
2058
+ )
2047
2059
  )
2048
2060
 
2049
2061
  for ij in range(nscale):
2050
2062
  idx = np.where(jo1 == ij)[0]
2051
2063
  if idx.shape[0] > noff:
2052
- c01[i, j, idx[:noff], k, l_orient] = self.add_data_from_slope(
2053
- c01[i, j, idx[noff:], k, l_orient], noff, ds=ds
2064
+ s3[i, j, idx[:noff], k, l_orient] = (
2065
+ self.add_data_from_slope(
2066
+ s3[i, j, idx[noff:], k, l_orient], noff, ds=ds
2067
+ )
2054
2068
  )
2055
2069
  else:
2056
- c01[i, j, idx, k, l_orient] = np.mean(
2057
- c01[i, j, jo1 == ij - 1, k, l_orient]
2070
+ s3[i, j, idx, k, l_orient] = np.mean(
2071
+ s3[i, j, jo1 == ij - 1, k, l_orient]
2058
2072
  )
2059
2073
 
2060
2074
  nout = 0
@@ -2063,14 +2077,14 @@ class scat_cov:
2063
2077
  for j1 in range(0, j2):
2064
2078
  nout = nout + 1
2065
2079
 
2066
- c11 = np.zeros(
2080
+ s4 = np.zeros(
2067
2081
  [
2068
- self.C11.shape[0],
2069
- self.C11.shape[1],
2082
+ self.S4.shape[0],
2083
+ self.S4.shape[1],
2070
2084
  nout,
2071
- self.C11.shape[3],
2072
- self.C11.shape[4],
2073
- self.C11.shape[5],
2085
+ self.S4.shape[3],
2086
+ self.S4.shape[4],
2087
+ self.S4.shape[5],
2074
2088
  ],
2075
2089
  dtype="complex",
2076
2090
  )
@@ -2088,7 +2102,7 @@ class scat_cov:
2088
2102
  jo3[nout] = j3
2089
2103
  nout = nout + 1
2090
2104
 
2091
- ncross = self.C11.shape[2]
2105
+ ncross = self.S4.shape[2]
2092
2106
  jj1 = np.zeros([ncross])
2093
2107
  jj2 = np.zeros([ncross])
2094
2108
  jj3 = np.zeros([ncross])
@@ -2108,29 +2122,31 @@ class scat_cov:
2108
2122
  idx = np.where((jj3 == j3) * (jj2 == j2))[0]
2109
2123
  if idx.shape[0] > 0:
2110
2124
  idx2 = np.where((jo3 == j3 + noff) * (jo2 == j2 + noff))[0]
2111
- for i in range(self.C11.shape[0]):
2112
- for j in range(self.C11.shape[1]):
2113
- for k in range(self.C11.shape[3]):
2114
- for l_orient in range(self.C11.shape[4]):
2115
- for m in range(self.C11.shape[5]):
2125
+ for i in range(self.S4.shape[0]):
2126
+ for j in range(self.S4.shape[1]):
2127
+ for k in range(self.S4.shape[3]):
2128
+ for l_orient in range(self.S4.shape[4]):
2129
+ for m in range(self.S4.shape[5]):
2116
2130
  if self.BACKEND == "numpy":
2117
- c11[i, j, idx2[noff:], k, l_orient, m] = self.C11[
2118
- i, j, idx, k, l_orient, m
2119
- ]
2120
- c11[i, j, idx2[:noff], k, l_orient, m] = (
2131
+ s4[i, j, idx2[noff:], k, l_orient, m] = (
2132
+ self.S4[i, j, idx, k, l_orient, m]
2133
+ )
2134
+ s4[i, j, idx2[:noff], k, l_orient, m] = (
2121
2135
  self.add_data_from_log_slope(
2122
- self.C11[i, j, idx, k, l_orient, m],
2136
+ self.S4[i, j, idx, k, l_orient, m],
2123
2137
  noff,
2124
2138
  ds=ds,
2125
2139
  )
2126
2140
  )
2127
2141
  else:
2128
- c11[i, j, idx2[noff:], k, l_orient, m] = (
2129
- self.C11.numpy()[i, j, idx, k, l_orient, m]
2130
- )
2131
- c11[i, j, idx2[:noff], k, l_orient, m] = (
2142
+ s4[
2143
+ i, j, idx2[noff:], k, l_orient, m
2144
+ ] = self.S4.numpy()[
2145
+ i, j, idx, k, l_orient, m
2146
+ ]
2147
+ s4[i, j, idx2[:noff], k, l_orient, m] = (
2132
2148
  self.add_data_from_log_slope(
2133
- self.C11.numpy()[
2149
+ self.S4.numpy()[
2134
2150
  i, j, idx, k, l_orient, m
2135
2151
  ],
2136
2152
  noff,
@@ -2138,7 +2154,7 @@ class scat_cov:
2138
2154
  )
2139
2155
  )
2140
2156
 
2141
- idx = np.where(abs(c11[0, 0, :, 0, 0, 0]) == 0)[0]
2157
+ idx = np.where(abs(s4[0, 0, :, 0, 0, 0]) == 0)[0]
2142
2158
  for iii in idx:
2143
2159
  iii1 = np.where(
2144
2160
  (jo1 == jo1[iii] + 1) * (jo2 == jo2[iii] + 1) * (jo3 == jo3[iii] + 1)
@@ -2147,16 +2163,20 @@ class scat_cov:
2147
2163
  (jo1 == jo1[iii] + 2) * (jo2 == jo2[iii] + 2) * (jo3 == jo3[iii] + 2)
2148
2164
  )[0]
2149
2165
  if iii2.shape[0] > 0:
2150
- for i in range(self.C11.shape[0]):
2151
- for j in range(self.C11.shape[1]):
2152
- for k in range(self.C11.shape[3]):
2153
- for l_orient in range(self.C11.shape[4]):
2154
- for m in range(self.C11.shape[5]):
2155
- c11[i, j, iii, k, l_orient, m] = self.add_data_from_slope(
2156
- c11[i, j, [iii1, iii2], k, l_orient, m], 1, ds=2
2157
- )[0]
2158
-
2159
- idx = np.where(abs(c11[0, 0, :, 0, 0, 0]) == 0)[0]
2166
+ for i in range(self.S4.shape[0]):
2167
+ for j in range(self.S4.shape[1]):
2168
+ for k in range(self.S4.shape[3]):
2169
+ for l_orient in range(self.S4.shape[4]):
2170
+ for m in range(self.S4.shape[5]):
2171
+ s4[i, j, iii, k, l_orient, m] = (
2172
+ self.add_data_from_slope(
2173
+ s4[i, j, [iii1, iii2], k, l_orient, m],
2174
+ 1,
2175
+ ds=2,
2176
+ )[0]
2177
+ )
2178
+
2179
+ idx = np.where(abs(s4[0, 0, :, 0, 0, 0]) == 0)[0]
2160
2180
  for iii in idx:
2161
2181
  iii1 = np.where(
2162
2182
  (jo1 == jo1[iii]) * (jo2 == jo2[iii]) * (jo3 == jo3[iii] - 1)
@@ -2165,20 +2185,24 @@ class scat_cov:
2165
2185
  (jo1 == jo1[iii]) * (jo2 == jo2[iii]) * (jo3 == jo3[iii] - 2)
2166
2186
  )[0]
2167
2187
  if iii2.shape[0] > 0:
2168
- for i in range(self.C11.shape[0]):
2169
- for j in range(self.C11.shape[1]):
2170
- for k in range(self.C11.shape[3]):
2171
- for l_orient in range(self.C11.shape[4]):
2172
- for m in range(self.C11.shape[5]):
2173
- c11[i, j, iii, k, l_orient, m] = self.add_data_from_slope(
2174
- c11[i, j, [iii1, iii2], k, l_orient, m], 1, ds=2
2175
- )[0]
2188
+ for i in range(self.S4.shape[0]):
2189
+ for j in range(self.S4.shape[1]):
2190
+ for k in range(self.S4.shape[3]):
2191
+ for l_orient in range(self.S4.shape[4]):
2192
+ for m in range(self.S4.shape[5]):
2193
+ s4[i, j, iii, k, l_orient, m] = (
2194
+ self.add_data_from_slope(
2195
+ s4[i, j, [iii1, iii2], k, l_orient, m],
2196
+ 1,
2197
+ ds=2,
2198
+ )[0]
2199
+ )
2176
2200
 
2177
2201
  return scat_cov(
2178
2202
  self.S0,
2179
- (p00),
2180
- (c01),
2181
- (c11),
2203
+ (s2),
2204
+ (s3),
2205
+ (s4),
2182
2206
  s1=(s1),
2183
2207
  backend=self.backend,
2184
2208
  use_1D=self.use_1D,
@@ -2195,83 +2219,107 @@ class funct(FOC.FoCUS):
2195
2219
  return self.fill_healpy(im, nullval=nullval)
2196
2220
 
2197
2221
  def moments(self, list_scat):
2198
- if isinstance(list_scat,foscat.scat_cov.scat_cov):
2199
- mS0 = self.backend.bk_expand_dims(self.backend.bk_reduce_mean(list_scat.S0,0),0)
2200
- mP00 = self.backend.bk_expand_dims(self.backend.bk_reduce_mean(list_scat.P00,0),0)
2201
- mC01 = self.backend.bk_expand_dims(self.backend.bk_reduce_mean(list_scat.C01,0),0)
2202
- mC11 = self.backend.bk_expand_dims(self.backend.bk_reduce_mean(list_scat.C11,0),0)
2203
- sS0 = self.backend.bk_expand_dims(self.backend.bk_reduce_std(list_scat.S0,0),0)
2204
- sP00 = self.backend.bk_expand_dims(self.backend.bk_reduce_std(list_scat.P00,0),0)
2205
- sC01 = self.backend.bk_expand_dims(self.backend.bk_reduce_std(list_scat.C01,0),0)
2206
- sC11 = self.backend.bk_expand_dims(self.backend.bk_reduce_std(list_scat.C11,0),0)
2222
+ if isinstance(list_scat, foscat.scat_cov.scat_cov):
2223
+ mS0 = self.backend.bk_expand_dims(
2224
+ self.backend.bk_reduce_mean(list_scat.S0, 0), 0
2225
+ )
2226
+ mS2 = self.backend.bk_expand_dims(
2227
+ self.backend.bk_reduce_mean(list_scat.S2, 0), 0
2228
+ )
2229
+ mS3 = self.backend.bk_expand_dims(
2230
+ self.backend.bk_reduce_mean(list_scat.S3, 0), 0
2231
+ )
2232
+ mS4 = self.backend.bk_expand_dims(
2233
+ self.backend.bk_reduce_mean(list_scat.S4, 0), 0
2234
+ )
2235
+ sS0 = self.backend.bk_expand_dims(
2236
+ self.backend.bk_reduce_std(list_scat.S0, 0), 0
2237
+ )
2238
+ sS2 = self.backend.bk_expand_dims(
2239
+ self.backend.bk_reduce_std(list_scat.S2, 0), 0
2240
+ )
2241
+ sS3 = self.backend.bk_expand_dims(
2242
+ self.backend.bk_reduce_std(list_scat.S3, 0), 0
2243
+ )
2244
+ sS4 = self.backend.bk_expand_dims(
2245
+ self.backend.bk_reduce_std(list_scat.S4, 0), 0
2246
+ )
2207
2247
 
2208
2248
  if list_scat.S1 is not None:
2209
- mS1 = self.backend.bk_expand_dims(self.backend.bk_reduce_mean(list_scat.S1,0),0)
2210
- sS1 = self.backend.bk_expand_dims(self.backend.bk_reduce_std(list_scat.S1,0),0)
2249
+ mS1 = self.backend.bk_expand_dims(
2250
+ self.backend.bk_reduce_mean(list_scat.S1, 0), 0
2251
+ )
2252
+ sS1 = self.backend.bk_expand_dims(
2253
+ self.backend.bk_reduce_std(list_scat.S1, 0), 0
2254
+ )
2211
2255
  else:
2212
2256
  mS1 = None
2213
2257
  sS1 = None
2214
- if list_scat.C10 is not None:
2215
- mC10 = self.backend.bk_expand_dims(self.backend.bk_reduce_mean(list_scat.C10,0),0)
2216
- sC10 = self.backend.bk_expand_dims(self.backend.bk_reduce_std(list_scat.C10,0),0)
2258
+ if list_scat.S3P is not None:
2259
+ mS3P = self.backend.bk_expand_dims(
2260
+ self.backend.bk_reduce_mean(list_scat.S3P, 0), 0
2261
+ )
2262
+ sS3P = self.backend.bk_expand_dims(
2263
+ self.backend.bk_reduce_std(list_scat.S3P, 0), 0
2264
+ )
2217
2265
  else:
2218
- mC10 = None
2219
- sC10 = None
2266
+ mS3P = None
2267
+ sS3P = None
2220
2268
  else:
2221
2269
  S0 = None
2222
2270
  for k in list_scat:
2223
2271
  tmp = list_scat[k]
2224
2272
  if self.BACKEND == "numpy":
2225
2273
  nS0 = np.expand_dims(tmp.S0, 0)
2226
- nP00 = np.expand_dims(tmp.P00, 0)
2227
- nC01 = np.expand_dims(tmp.C01, 0)
2228
- nC11 = np.expand_dims(tmp.C11, 0)
2229
- if tmp.C10 is not None:
2230
- nC10 = np.expand_dims(tmp.C10, 0)
2274
+ nS2 = np.expand_dims(tmp.S2, 0)
2275
+ nS3 = np.expand_dims(tmp.S3, 0)
2276
+ nS4 = np.expand_dims(tmp.S4, 0)
2277
+ if tmp.S3P is not None:
2278
+ nS3P = np.expand_dims(tmp.S3P, 0)
2231
2279
  if tmp.S1 is not None:
2232
2280
  nS1 = np.expand_dims(tmp.S1, 0)
2233
2281
  else:
2234
2282
  nS0 = np.expand_dims(tmp.S0.numpy(), 0)
2235
- nP00 = np.expand_dims(tmp.P00.numpy(), 0)
2236
- nC01 = np.expand_dims(tmp.C01.numpy(), 0)
2237
- nC11 = np.expand_dims(tmp.C11.numpy(), 0)
2238
- if tmp.C10 is not None:
2239
- nC10 = np.expand_dims(tmp.C10.numpy(), 0)
2283
+ nS2 = np.expand_dims(tmp.S2.numpy(), 0)
2284
+ nS3 = np.expand_dims(tmp.S3.numpy(), 0)
2285
+ nS4 = np.expand_dims(tmp.S4.numpy(), 0)
2286
+ if tmp.S3P is not None:
2287
+ nS3P = np.expand_dims(tmp.S3P.numpy(), 0)
2240
2288
  if tmp.S1 is not None:
2241
2289
  nS1 = np.expand_dims(tmp.S1.numpy(), 0)
2242
2290
 
2243
2291
  if S0 is None:
2244
2292
  S0 = nS0
2245
- P00 = nP00
2246
- C01 = nC01
2247
- C11 = nC11
2248
- if tmp.C10 is not None:
2249
- C10 = nC10
2293
+ S2 = nS2
2294
+ S3 = nS3
2295
+ S4 = nS4
2296
+ if tmp.S3P is not None:
2297
+ S3P = nS3P
2250
2298
  if tmp.S1 is not None:
2251
2299
  S1 = nS1
2252
2300
  else:
2253
2301
  S0 = np.concatenate([S0, nS0], 0)
2254
- P00 = np.concatenate([P00, nP00], 0)
2255
- C01 = np.concatenate([C01, nC01], 0)
2256
- C11 = np.concatenate([C11, nC11], 0)
2257
- if tmp.C10 is not None:
2258
- C10 = np.concatenate([C10, nC10], 0)
2302
+ S2 = np.concatenate([S2, nS2], 0)
2303
+ S3 = np.concatenate([S3, nS3], 0)
2304
+ S4 = np.concatenate([S4, nS4], 0)
2305
+ if tmp.S3P is not None:
2306
+ S3P = np.concatenate([S3P, nS3P], 0)
2259
2307
  if tmp.S1 is not None:
2260
2308
  S1 = np.concatenate([S1, nS1], 0)
2261
2309
  sS0 = np.std(S0, 0)
2262
- sP00 = np.std(P00, 0)
2263
- sC01 = np.std(C01, 0)
2264
- sC11 = np.std(C11, 0)
2310
+ sS2 = np.std(S2, 0)
2311
+ sS3 = np.std(S3, 0)
2312
+ sS4 = np.std(S4, 0)
2265
2313
  mS0 = np.mean(S0, 0)
2266
- mP00 = np.mean(P00, 0)
2267
- mC01 = np.mean(C01, 0)
2268
- mC11 = np.mean(C11, 0)
2269
- if tmp.C10 is not None:
2270
- sC10 = np.std(C10, 0)
2271
- mC10 = np.mean(C10, 0)
2314
+ mS2 = np.mean(S2, 0)
2315
+ mS3 = np.mean(S3, 0)
2316
+ mS4 = np.mean(S4, 0)
2317
+ if tmp.S3P is not None:
2318
+ sS3P = np.std(S3P, 0)
2319
+ mS3P = np.mean(S3P, 0)
2272
2320
  else:
2273
- sC10 = None
2274
- mC10 = None
2321
+ sS3P = None
2322
+ mS3P = None
2275
2323
 
2276
2324
  if tmp.S1 is not None:
2277
2325
  sS1 = np.std(S1, 0)
@@ -2282,20 +2330,20 @@ class funct(FOC.FoCUS):
2282
2330
 
2283
2331
  return scat_cov(
2284
2332
  mS0,
2285
- mP00,
2286
- mC01,
2287
- mC11,
2333
+ mS2,
2334
+ mS3,
2335
+ mS4,
2288
2336
  s1=mS1,
2289
- c10=mC10,
2337
+ s3p=mS3P,
2290
2338
  backend=self.backend,
2291
2339
  use_1D=self.use_1D,
2292
2340
  ), scat_cov(
2293
2341
  sS0,
2294
- sP00,
2295
- sC01,
2296
- sC11,
2342
+ sS2,
2343
+ sS3,
2344
+ sS4,
2297
2345
  s1=sS1,
2298
- c10=sC10,
2346
+ s3p=sS3P,
2299
2347
  backend=self.backend,
2300
2348
  use_1D=self.use_1D,
2301
2349
  )
@@ -2400,12 +2448,12 @@ class funct(FOC.FoCUS):
2400
2448
  lidx = np.arange(sim.shape[1])
2401
2449
  for m in range(4):
2402
2450
  for l_orient in range(4):
2403
- mat2[k2, lidx, m, 4 * ((l_orient + iph[:, m]) % 4) + l_orient] = (
2404
- 1.0 - alpha[:, m]
2405
- )
2406
- mat2[k2, lidx, m, 4 * ((l_orient + iph[:, m] + 1) % 4) + l_orient] = alpha[
2407
- :, m
2408
- ]
2451
+ mat2[
2452
+ k2, lidx, m, 4 * ((l_orient + iph[:, m]) % 4) + l_orient
2453
+ ] = (1.0 - alpha[:, m])
2454
+ mat2[
2455
+ k2, lidx, m, 4 * ((l_orient + iph[:, m] + 1) % 4) + l_orient
2456
+ ] = alpha[:, m]
2409
2457
 
2410
2458
  cmat2[k] = self.backend.bk_cast(mat2.astype("complex64"))
2411
2459
  """
@@ -2456,14 +2504,14 @@ class funct(FOC.FoCUS):
2456
2504
  S1 = <|I * Psi_j3|>
2457
2505
  Normalization : take the log
2458
2506
  power spectrum:
2459
- P00 = <|I * Psi_j3|^2>
2507
+ S2 = <|I * Psi_j3|^2>
2460
2508
  Normalization : take the log
2461
2509
  orig. x modulus:
2462
- C01 = < (I * Psi)_j3 x (|I * Psi_j2| * Psi_j3)^* >
2463
- Normalization : divide by (P00_j2 * P00_j3)^0.5
2510
+ S3 = < (I * Psi)_j3 x (|I * Psi_j2| * Psi_j3)^* >
2511
+ Normalization : divide by (S2_j2 * S2_j3)^0.5
2464
2512
  modulus x modulus:
2465
- C11 = <(|I * psi1| * psi3)(|I * psi2| * psi3)^*>
2466
- Normalization : divide by (P00_j1 * P00_j2)^0.5
2513
+ S4 = <(|I * psi1| * psi3)(|I * psi2| * psi3)^*>
2514
+ Normalization : divide by (S2_j1 * S2_j2)^0.5
2467
2515
  Parameters
2468
2516
  ----------
2469
2517
  image1: tensor
@@ -2472,14 +2520,14 @@ class funct(FOC.FoCUS):
2472
2520
  Second image. If not None, we compute cross-scattering covariance coefficients.
2473
2521
  mask:
2474
2522
  norm: None or str
2475
- If None no normalization is applied, if 'auto' normalize by the reference P00,
2476
- if 'self' normalize by the current P00.
2523
+ If None no normalization is applied, if 'auto' normalize by the reference S2,
2524
+ if 'self' normalize by the current S2.
2477
2525
  all_cross: False or True
2478
2526
  If False compute all the coefficient even the Imaginary part,
2479
2527
  If True return only the terms computable in the auto case.
2480
2528
  Returns
2481
2529
  -------
2482
- S1, P00, C01, C11 normalized
2530
+ S1, S2, S3, S4 normalized
2483
2531
  """
2484
2532
  return_data = self.return_data
2485
2533
  # Check input consistency
@@ -2628,22 +2676,22 @@ class funct(FOC.FoCUS):
2628
2676
 
2629
2677
  ### INITIALIZATION
2630
2678
  # Coefficients
2631
- S1, P00, C01, C11, C10 = None, None, None, None, None
2679
+ S1, S2, S3, S4, S3P = None, None, None, None, None
2632
2680
 
2633
- off_P0 = -2
2634
- off_C01 = -3
2635
- off_C11 = -4
2681
+ off_S2 = -2
2682
+ off_S3 = -3
2683
+ off_S4 = -4
2636
2684
  if self.use_1D:
2637
- off_P0 = -1
2638
- off_C01 = -1
2639
- off_C11 = -1
2685
+ off_S2 = -1
2686
+ off_S3 = -1
2687
+ off_S4 = -1
2640
2688
 
2641
- # Dictionaries for C01 computation
2689
+ # Dictionaries for S3 computation
2642
2690
  M1_dic = {} # M stands for Module M1 = |I1 * Psi|
2643
2691
  if cross:
2644
2692
  M2_dic = {}
2645
2693
 
2646
- # P00 for normalization
2694
+ # S2 for normalization
2647
2695
  cond_init_P1_dic = (norm == "self") or (
2648
2696
  (norm == "auto") and (self.P1_dic is None)
2649
2697
  )
@@ -2670,23 +2718,23 @@ class funct(FOC.FoCUS):
2670
2718
  vs0 = self.backend.bk_concat([l_vs0, l_vs0], 1)
2671
2719
  s0 = self.backend.bk_concat([s0, l_vs0], 1)
2672
2720
 
2673
- #### COMPUTE S1, P00, C01 and C11
2721
+ #### COMPUTE S1, S2, S3 and S4
2674
2722
  nside_j3 = nside # NSIDE start (nside_j3 = nside / 2^j3)
2675
2723
  for j3 in range(Jmax):
2676
2724
  if return_data:
2677
- if C01 is None:
2678
- C01 = {}
2679
- C01[j3] = None
2725
+ if S3 is None:
2726
+ S3 = {}
2727
+ S3[j3] = None
2680
2728
 
2681
- if C10 is None:
2682
- C10 = {}
2683
- C10[j3] = None
2729
+ if S3P is None:
2730
+ S3P = {}
2731
+ S3P[j3] = None
2684
2732
 
2685
- if C11 is None:
2686
- C11 = {}
2687
- C11[j3] = None
2733
+ if S4 is None:
2734
+ S4 = {}
2735
+ S4[j3] = None
2688
2736
 
2689
- ####### S1 and P00
2737
+ ####### S1 and S2
2690
2738
  ### Make the convolution I1 * Psi_j3
2691
2739
  conv1 = self.convol(I1, axis=1) # [Nbatch, Npix_j3, Norient3]
2692
2740
 
@@ -2694,7 +2742,7 @@ class funct(FOC.FoCUS):
2694
2742
  tmp2 = self.backend.bk_repeat(conv1, 4, axis=-1)
2695
2743
  conv1 = self.backend.bk_reduce_sum(
2696
2744
  self.backend.bk_reshape(
2697
- cmat[j3] * tmp2, [1, cmat[j3].shape[0], 4, 4]
2745
+ cmat[j3] * tmp2, [tmp2.shape[0], cmat[j3].shape[0], 4, 4]
2698
2746
  ),
2699
2747
  2,
2700
2748
  )
@@ -2710,45 +2758,45 @@ class funct(FOC.FoCUS):
2710
2758
  if not cross: # Auto
2711
2759
  M1_square = self.backend.bk_real(M1_square)
2712
2760
 
2713
- ### P00_auto = < M1^2 >_pix
2761
+ ### S2_auto = < M1^2 >_pix
2714
2762
  # Apply the mask [Nmask, Npix_j3] and average over pixels
2715
2763
  if return_data:
2716
- p00 = M1_square
2764
+ s2 = M1_square
2717
2765
  else:
2718
2766
  if calc_var:
2719
- p00, vp00 = self.masked_mean(
2767
+ s2, vs2 = self.masked_mean(
2720
2768
  M1_square, vmask, axis=1, rank=j3, calc_var=True
2721
2769
  )
2722
2770
  else:
2723
- p00 = self.masked_mean(M1_square, vmask, axis=1, rank=j3)
2771
+ s2 = self.masked_mean(M1_square, vmask, axis=1, rank=j3)
2724
2772
 
2725
2773
  if cond_init_P1_dic:
2726
- # We fill P1_dic with P00 for normalisation of C01 and C11
2727
- P1_dic[j3] = self.backend.bk_real(p00) # [Nbatch, Nmask, Norient3]
2774
+ # We fill P1_dic with S2 for normalisation of S3 and S4
2775
+ P1_dic[j3] = self.backend.bk_real(s2) # [Nbatch, Nmask, Norient3]
2728
2776
 
2729
- # We store P00_auto to return it [Nbatch, Nmask, NP00, Norient3]
2777
+ # We store S2_auto to return it [Nbatch, Nmask, NS2, Norient3]
2730
2778
  if return_data:
2731
- if P00 is None:
2732
- P00 = {}
2733
- P00[j3] = p00
2779
+ if S2 is None:
2780
+ S2 = {}
2781
+ S2[j3] = s2
2734
2782
  else:
2735
- if norm == "auto": # Normalize P00
2736
- p00 /= P1_dic[j3]
2737
- if P00 is None:
2738
- P00 = self.backend.bk_expand_dims(
2739
- p00, off_P0
2740
- ) # Add a dimension for NP00
2783
+ if norm == "auto": # Normalize S2
2784
+ s2 /= P1_dic[j3]
2785
+ if S2 is None:
2786
+ S2 = self.backend.bk_expand_dims(
2787
+ s2, off_S2
2788
+ ) # Add a dimension for NS2
2741
2789
  if calc_var:
2742
- VP00 = self.backend.bk_expand_dims(
2743
- vp00, off_P0
2744
- ) # Add a dimension for NP00
2790
+ VS2 = self.backend.bk_expand_dims(
2791
+ vs2, off_S2
2792
+ ) # Add a dimension for NS2
2745
2793
  else:
2746
- P00 = self.backend.bk_concat(
2747
- [P00, self.backend.bk_expand_dims(p00, off_P0)], axis=2
2794
+ S2 = self.backend.bk_concat(
2795
+ [S2, self.backend.bk_expand_dims(s2, off_S2)], axis=2
2748
2796
  )
2749
2797
  if calc_var:
2750
- VP00 = self.backend.bk_concat(
2751
- [VP00, self.backend.bk_expand_dims(vp00, off_P0)],
2798
+ VS2 = self.backend.bk_concat(
2799
+ [VS2, self.backend.bk_expand_dims(vs2, off_S2)],
2752
2800
  axis=2,
2753
2801
  )
2754
2802
 
@@ -2778,19 +2826,19 @@ class funct(FOC.FoCUS):
2778
2826
  ### We store S1 for image1 [Nbatch, Nmask, NS1, Norient3]
2779
2827
  if S1 is None:
2780
2828
  S1 = self.backend.bk_expand_dims(
2781
- s1, off_P0
2829
+ s1, off_S2
2782
2830
  ) # Add a dimension for NS1
2783
2831
  if calc_var:
2784
2832
  VS1 = self.backend.bk_expand_dims(
2785
- vs1, off_P0
2833
+ vs1, off_S2
2786
2834
  ) # Add a dimension for NS1
2787
2835
  else:
2788
2836
  S1 = self.backend.bk_concat(
2789
- [S1, self.backend.bk_expand_dims(s1, off_P0)], axis=2
2837
+ [S1, self.backend.bk_expand_dims(s1, off_S2)], axis=2
2790
2838
  )
2791
2839
  if calc_var:
2792
2840
  VS1 = self.backend.bk_concat(
2793
- [VS1, self.backend.bk_expand_dims(vs1, off_P0)], axis=2
2841
+ [VS1, self.backend.bk_expand_dims(vs1, off_S2)], axis=2
2794
2842
  )
2795
2843
 
2796
2844
  else: # Cross
@@ -2800,7 +2848,7 @@ class funct(FOC.FoCUS):
2800
2848
  tmp2 = self.backend.bk_repeat(conv2, 4, axis=-1)
2801
2849
  conv2 = self.backend.bk_reduce_sum(
2802
2850
  self.backend.bk_reshape(
2803
- cmat[j3] * tmp2, [1, cmat[j3].shape[0], 4, 4]
2851
+ cmat[j3] * tmp2, [tmp2.shape[0], cmat[j3].shape[0], 4, 4]
2804
2852
  ),
2805
2853
  2,
2806
2854
  )
@@ -2812,7 +2860,7 @@ class funct(FOC.FoCUS):
2812
2860
  # Store M2_j3 in a dictionary
2813
2861
  M2_dic[j3] = M2
2814
2862
 
2815
- ### P00_auto = < M2^2 >_pix
2863
+ ### S2_auto = < M2^2 >_pix
2816
2864
  # Not returned, only for normalization
2817
2865
  if cond_init_P1_dic:
2818
2866
  # Apply the mask [Nmask, Npix_j3] and average over pixels
@@ -2834,53 +2882,53 @@ class funct(FOC.FoCUS):
2834
2882
  p2 = self.masked_mean(
2835
2883
  M2_square, vmask, axis=1, rank=j3
2836
2884
  ) # [Nbatch, Nmask, Norient3]
2837
- # We fill P1_dic with P00 for normalisation of C01 and C11
2885
+ # We fill P1_dic with S2 for normalisation of S3 and S4
2838
2886
  P1_dic[j3] = self.backend.bk_real(p1) # [Nbatch, Nmask, Norient3]
2839
2887
  P2_dic[j3] = self.backend.bk_real(p2) # [Nbatch, Nmask, Norient3]
2840
2888
 
2841
- ### P00_cross = < (I1 * Psi_j3) (I2 * Psi_j3)^* >_pix
2889
+ ### S2_cross = < (I1 * Psi_j3) (I2 * Psi_j3)^* >_pix
2842
2890
  # z_1 x z_2^* = (a1a2 + b1b2) + i(b1a2 - a1b2)
2843
- p00 = conv1 * self.backend.bk_conjugate(conv2)
2844
- MX = self.backend.bk_L1(p00)
2891
+ s2 = conv1 * self.backend.bk_conjugate(conv2)
2892
+ MX = self.backend.bk_L1(s2)
2845
2893
  # Apply the mask [Nmask, Npix_j3] and average over pixels
2846
2894
  if return_data:
2847
- p00 = p00
2895
+ s2 = s2
2848
2896
  else:
2849
2897
  if calc_var:
2850
- p00, vp00 = self.masked_mean(
2851
- p00, vmask, axis=1, rank=j3, calc_var=True
2898
+ s2, vs2 = self.masked_mean(
2899
+ s2, vmask, axis=1, rank=j3, calc_var=True
2852
2900
  )
2853
2901
  else:
2854
- p00 = self.masked_mean(p00, vmask, axis=1, rank=j3)
2902
+ s2 = self.masked_mean(s2, vmask, axis=1, rank=j3)
2855
2903
 
2856
2904
  if return_data:
2857
- if P00 is None:
2858
- P00 = {}
2859
- P00[j3] = p00
2905
+ if S2 is None:
2906
+ S2 = {}
2907
+ S2[j3] = s2
2860
2908
  else:
2861
- ### Normalize P00_cross
2909
+ ### Normalize S2_cross
2862
2910
  if norm == "auto":
2863
- p00 /= (P1_dic[j3] * P2_dic[j3]) ** 0.5
2911
+ s2 /= (P1_dic[j3] * P2_dic[j3]) ** 0.5
2864
2912
 
2865
- ### Store P00_cross as complex [Nbatch, Nmask, NP00, Norient3]
2913
+ ### Store S2_cross as complex [Nbatch, Nmask, NS2, Norient3]
2866
2914
  if not all_cross:
2867
- p00 = self.backend.bk_real(p00)
2915
+ s2 = self.backend.bk_real(s2)
2868
2916
 
2869
- if P00 is None:
2870
- P00 = self.backend.bk_expand_dims(
2871
- p00, off_P0
2872
- ) # Add a dimension for NP00
2917
+ if S2 is None:
2918
+ S2 = self.backend.bk_expand_dims(
2919
+ s2, off_S2
2920
+ ) # Add a dimension for NS2
2873
2921
  if calc_var:
2874
- VP00 = self.backend.bk_expand_dims(
2875
- vp00, off_P0
2876
- ) # Add a dimension for NP00
2922
+ VS2 = self.backend.bk_expand_dims(
2923
+ vs2, off_S2
2924
+ ) # Add a dimension for NS2
2877
2925
  else:
2878
- P00 = self.backend.bk_concat(
2879
- [P00, self.backend.bk_expand_dims(p00, off_P0)], axis=2
2926
+ S2 = self.backend.bk_concat(
2927
+ [S2, self.backend.bk_expand_dims(s2, off_S2)], axis=2
2880
2928
  )
2881
2929
  if calc_var:
2882
- VP00 = self.backend.bk_concat(
2883
- [VP00, self.backend.bk_expand_dims(vp00, off_P0)],
2930
+ VS2 = self.backend.bk_concat(
2931
+ [VS2, self.backend.bk_expand_dims(vs2, off_S2)],
2884
2932
  axis=2,
2885
2933
  )
2886
2934
 
@@ -2909,19 +2957,19 @@ class funct(FOC.FoCUS):
2909
2957
  ### We store S1 for image1 [Nbatch, Nmask, NS1, Norient3]
2910
2958
  if S1 is None:
2911
2959
  S1 = self.backend.bk_expand_dims(
2912
- s1, off_P0
2960
+ s1, off_S2
2913
2961
  ) # Add a dimension for NS1
2914
2962
  if calc_var:
2915
2963
  VS1 = self.backend.bk_expand_dims(
2916
- vs1, off_P0
2964
+ vs1, off_S2
2917
2965
  ) # Add a dimension for NS1
2918
2966
  else:
2919
2967
  S1 = self.backend.bk_concat(
2920
- [S1, self.backend.bk_expand_dims(s1, off_P0)], axis=2
2968
+ [S1, self.backend.bk_expand_dims(s1, off_S2)], axis=2
2921
2969
  )
2922
2970
  if calc_var:
2923
2971
  VS1 = self.backend.bk_concat(
2924
- [VS1, self.backend.bk_expand_dims(vs1, off_P0)], axis=2
2972
+ [VS1, self.backend.bk_expand_dims(vs1, off_S2)], axis=2
2925
2973
  )
2926
2974
 
2927
2975
  # Initialize dictionaries for |I1*Psi_j| * Psi_j3
@@ -2930,17 +2978,17 @@ class funct(FOC.FoCUS):
2930
2978
  # Initialize dictionaries for |I2*Psi_j| * Psi_j3
2931
2979
  M2convPsi_dic = {}
2932
2980
 
2933
- ###### C01
2981
+ ###### S3
2934
2982
  for j2 in range(0, j3 + 1): # j2 <= j3
2935
2983
  if return_data:
2936
- if C11[j3] is None:
2937
- C11[j3] = {}
2938
- C11[j3][j2] = None
2984
+ if S4[j3] is None:
2985
+ S4[j3] = {}
2986
+ S4[j3][j2] = None
2939
2987
 
2940
- ### C01_auto = < (I1 * Psi)_j3 x (|I1 * Psi_j2| * Psi_j3)^* >_pix
2988
+ ### S3_auto = < (I1 * Psi)_j3 x (|I1 * Psi_j2| * Psi_j3)^* >_pix
2941
2989
  if not cross:
2942
2990
  if calc_var:
2943
- c01, vc01 = self._compute_C01(
2991
+ s3, vs3 = self._compute_S3(
2944
2992
  j2,
2945
2993
  j3,
2946
2994
  conv1,
@@ -2951,7 +2999,7 @@ class funct(FOC.FoCUS):
2951
2999
  cmat2=cmat2,
2952
3000
  ) # [Nbatch, Nmask, Norient3, Norient2]
2953
3001
  else:
2954
- c01 = self._compute_C01(
3002
+ s3 = self._compute_S3(
2955
3003
  j2,
2956
3004
  j3,
2957
3005
  conv1,
@@ -2963,45 +3011,45 @@ class funct(FOC.FoCUS):
2963
3011
  ) # [Nbatch, Nmask, Norient3, Norient2]
2964
3012
 
2965
3013
  if return_data:
2966
- if C01[j3] is None:
2967
- C01[j3] = {}
2968
- C01[j3][j2] = c01
3014
+ if S3[j3] is None:
3015
+ S3[j3] = {}
3016
+ S3[j3][j2] = s3
2969
3017
  else:
2970
- ### Normalize C01 with P00_j [Nbatch, Nmask, Norient_j]
3018
+ ### Normalize S3 with S2_j [Nbatch, Nmask, Norient_j]
2971
3019
  if norm is not None:
2972
3020
  self.div_norm(
2973
- c01,
3021
+ s3,
2974
3022
  (
2975
- self.backend.bk_expand_dims(P1_dic[j2], off_P0)
3023
+ self.backend.bk_expand_dims(P1_dic[j2], off_S2)
2976
3024
  * self.backend.bk_expand_dims(P1_dic[j3], -1)
2977
3025
  )
2978
3026
  ** 0.5,
2979
3027
  ) # [Nbatch, Nmask, Norient3, Norient2]
2980
3028
 
2981
- ### Store C01 as a complex [Nbatch, Nmask, NC01, Norient3, Norient2]
2982
- if C01 is None:
2983
- C01 = self.backend.bk_expand_dims(
2984
- c01, off_C01
2985
- ) # Add a dimension for NC01
3029
+ ### Store S3 as a complex [Nbatch, Nmask, NS3, Norient3, Norient2]
3030
+ if S3 is None:
3031
+ S3 = self.backend.bk_expand_dims(
3032
+ s3, off_S3
3033
+ ) # Add a dimension for NS3
2986
3034
  if calc_var:
2987
- VC01 = self.backend.bk_expand_dims(
2988
- vc01, off_C01
2989
- ) # Add a dimension for NC01
3035
+ VS3 = self.backend.bk_expand_dims(
3036
+ vs3, off_S3
3037
+ ) # Add a dimension for NS3
2990
3038
  else:
2991
- C01 = self.backend.bk_concat(
2992
- [C01, self.backend.bk_expand_dims(c01, off_C01)], axis=2
2993
- ) # Add a dimension for NC01
3039
+ S3 = self.backend.bk_concat(
3040
+ [S3, self.backend.bk_expand_dims(s3, off_S3)], axis=2
3041
+ ) # Add a dimension for NS3
2994
3042
  if calc_var:
2995
- VC01 = self.backend.bk_concat(
2996
- [VC01, self.backend.bk_expand_dims(vc01, off_C01)],
3043
+ VS3 = self.backend.bk_concat(
3044
+ [VS3, self.backend.bk_expand_dims(vs3, off_S3)],
2997
3045
  axis=2,
2998
- ) # Add a dimension for NC01
3046
+ ) # Add a dimension for NS3
2999
3047
 
3000
- ### C01_cross = < (I1 * Psi)_j3 x (|I2 * Psi_j2| * Psi_j3)^* >_pix
3001
- ### C10_cross = < (I2 * Psi)_j3 x (|I1 * Psi_j2| * Psi_j3)^* >_pix
3048
+ ### S3_cross = < (I1 * Psi)_j3 x (|I2 * Psi_j2| * Psi_j3)^* >_pix
3049
+ ### S3P_cross = < (I2 * Psi)_j3 x (|I1 * Psi_j2| * Psi_j3)^* >_pix
3002
3050
  else:
3003
3051
  if calc_var:
3004
- c01, vc01 = self._compute_C01(
3052
+ s3, vs3 = self._compute_S3(
3005
3053
  j2,
3006
3054
  j3,
3007
3055
  conv1,
@@ -3011,7 +3059,7 @@ class funct(FOC.FoCUS):
3011
3059
  calc_var=True,
3012
3060
  cmat2=cmat2,
3013
3061
  )
3014
- c10, vc10 = self._compute_C01(
3062
+ s3p, vs3p = self._compute_S3(
3015
3063
  j2,
3016
3064
  j3,
3017
3065
  conv2,
@@ -3022,7 +3070,7 @@ class funct(FOC.FoCUS):
3022
3070
  cmat2=cmat2,
3023
3071
  )
3024
3072
  else:
3025
- c01 = self._compute_C01(
3073
+ s3 = self._compute_S3(
3026
3074
  j2,
3027
3075
  j3,
3028
3076
  conv1,
@@ -3032,7 +3080,7 @@ class funct(FOC.FoCUS):
3032
3080
  return_data=return_data,
3033
3081
  cmat2=cmat2,
3034
3082
  )
3035
- c10 = self._compute_C01(
3083
+ s3p = self._compute_S3(
3036
3084
  j2,
3037
3085
  j3,
3038
3086
  conv2,
@@ -3044,73 +3092,73 @@ class funct(FOC.FoCUS):
3044
3092
  )
3045
3093
 
3046
3094
  if return_data:
3047
- if C01[j3] is None:
3048
- C01[j3] = {}
3049
- C10[j3] = {}
3050
- C01[j3][j2] = c01
3051
- C10[j3][j2] = c10
3095
+ if S3[j3] is None:
3096
+ S3[j3] = {}
3097
+ S3P[j3] = {}
3098
+ S3[j3][j2] = s3
3099
+ S3P[j3][j2] = s3p
3052
3100
  else:
3053
- ### Normalize C01 and C10 with P00_j [Nbatch, Nmask, Norient_j]
3101
+ ### Normalize S3 and S3P with S2_j [Nbatch, Nmask, Norient_j]
3054
3102
  if norm is not None:
3055
3103
  self.div_norm(
3056
- c01,
3104
+ s3,
3057
3105
  (
3058
- self.backend.bk_expand_dims(P2_dic[j2], off_P0)
3106
+ self.backend.bk_expand_dims(P2_dic[j2], off_S2)
3059
3107
  * self.backend.bk_expand_dims(P1_dic[j3], -1)
3060
3108
  )
3061
3109
  ** 0.5,
3062
3110
  ) # [Nbatch, Nmask, Norient3, Norient2]
3063
3111
  self.div_norm(
3064
- c10,
3112
+ s3p,
3065
3113
  (
3066
- self.backend.bk_expand_dims(P1_dic[j2], off_P0)
3114
+ self.backend.bk_expand_dims(P1_dic[j2], off_S2)
3067
3115
  * self.backend.bk_expand_dims(P2_dic[j3], -1)
3068
3116
  )
3069
3117
  ** 0.5,
3070
3118
  ) # [Nbatch, Nmask, Norient3, Norient2]
3071
3119
 
3072
- ### Store C01 and C10 as a complex [Nbatch, Nmask, NC01, Norient3, Norient2]
3073
- if C01 is None:
3074
- C01 = self.backend.bk_expand_dims(
3075
- c01, off_C01
3076
- ) # Add a dimension for NC01
3120
+ ### Store S3 and S3P as a complex [Nbatch, Nmask, NS3, Norient3, Norient2]
3121
+ if S3 is None:
3122
+ S3 = self.backend.bk_expand_dims(
3123
+ s3, off_S3
3124
+ ) # Add a dimension for NS3
3077
3125
  if calc_var:
3078
- VC01 = self.backend.bk_expand_dims(
3079
- vc01, off_C01
3080
- ) # Add a dimension for NC01
3126
+ VS3 = self.backend.bk_expand_dims(
3127
+ vs3, off_S3
3128
+ ) # Add a dimension for NS3
3081
3129
  else:
3082
- C01 = self.backend.bk_concat(
3083
- [C01, self.backend.bk_expand_dims(c01, off_C01)], axis=2
3084
- ) # Add a dimension for NC01
3130
+ S3 = self.backend.bk_concat(
3131
+ [S3, self.backend.bk_expand_dims(s3, off_S3)], axis=2
3132
+ ) # Add a dimension for NS3
3085
3133
  if calc_var:
3086
- VC01 = self.backend.bk_concat(
3087
- [VC01, self.backend.bk_expand_dims(vc01, off_C01)],
3134
+ VS3 = self.backend.bk_concat(
3135
+ [VS3, self.backend.bk_expand_dims(vs3, off_S3)],
3088
3136
  axis=2,
3089
- ) # Add a dimension for NC01
3090
- if C10 is None:
3091
- C10 = self.backend.bk_expand_dims(
3092
- c10, off_C01
3093
- ) # Add a dimension for NC01
3137
+ ) # Add a dimension for NS3
3138
+ if S3P is None:
3139
+ S3P = self.backend.bk_expand_dims(
3140
+ s3p, off_S3
3141
+ ) # Add a dimension for NS3
3094
3142
  if calc_var:
3095
- VC10 = self.backend.bk_expand_dims(
3096
- vc10, off_C01
3097
- ) # Add a dimension for NC01
3143
+ VS3P = self.backend.bk_expand_dims(
3144
+ vs3p, off_S3
3145
+ ) # Add a dimension for NS3
3098
3146
  else:
3099
- C10 = self.backend.bk_concat(
3100
- [C10, self.backend.bk_expand_dims(c10, off_C01)], axis=2
3101
- ) # Add a dimension for NC01
3147
+ S3P = self.backend.bk_concat(
3148
+ [S3P, self.backend.bk_expand_dims(s3p, off_S3)], axis=2
3149
+ ) # Add a dimension for NS3
3102
3150
  if calc_var:
3103
- VC10 = self.backend.bk_concat(
3104
- [VC10, self.backend.bk_expand_dims(vc10, off_C01)],
3151
+ VS3P = self.backend.bk_concat(
3152
+ [VS3P, self.backend.bk_expand_dims(vs3p, off_S3)],
3105
3153
  axis=2,
3106
- ) # Add a dimension for NC01
3154
+ ) # Add a dimension for NS3
3107
3155
 
3108
- ##### C11
3156
+ ##### S4
3109
3157
  for j1 in range(0, j2 + 1): # j1 <= j2
3110
- ### C11_auto = <(|I1 * psi1| * psi3)(|I1 * psi2| * psi3)^*>
3158
+ ### S4_auto = <(|I1 * psi1| * psi3)(|I1 * psi2| * psi3)^*>
3111
3159
  if not cross:
3112
3160
  if calc_var:
3113
- c11, vc11 = self._compute_C11(
3161
+ s4, vs4 = self._compute_S4(
3114
3162
  j1,
3115
3163
  j2,
3116
3164
  vmask,
@@ -3119,7 +3167,7 @@ class funct(FOC.FoCUS):
3119
3167
  calc_var=True,
3120
3168
  ) # [Nbatch, Nmask, Norient3, Norient2, Norient1]
3121
3169
  else:
3122
- c11 = self._compute_C11(
3170
+ s4 = self._compute_S4(
3123
3171
  j1,
3124
3172
  j2,
3125
3173
  vmask,
@@ -3129,57 +3177,57 @@ class funct(FOC.FoCUS):
3129
3177
  ) # [Nbatch, Nmask, Norient3, Norient2, Norient1]
3130
3178
 
3131
3179
  if return_data:
3132
- if C11[j3][j2] is None:
3133
- C11[j3][j2] = {}
3134
- C11[j3][j2][j1] = c11
3180
+ if S4[j3][j2] is None:
3181
+ S4[j3][j2] = {}
3182
+ S4[j3][j2][j1] = s4
3135
3183
  else:
3136
- ### Normalize C11 with P00_j [Nbatch, Nmask, Norient_j]
3184
+ ### Normalize S4 with S2_j [Nbatch, Nmask, Norient_j]
3137
3185
  if norm is not None:
3138
3186
  self.div_norm(
3139
- c11,
3187
+ s4,
3140
3188
  (
3141
3189
  self.backend.bk_expand_dims(
3142
3190
  self.backend.bk_expand_dims(
3143
- P1_dic[j1], off_P0
3191
+ P1_dic[j1], off_S2
3144
3192
  ),
3145
- off_P0,
3193
+ off_S2,
3146
3194
  )
3147
3195
  * self.backend.bk_expand_dims(
3148
3196
  self.backend.bk_expand_dims(
3149
- P1_dic[j2], off_P0
3197
+ P1_dic[j2], off_S2
3150
3198
  ),
3151
3199
  -1,
3152
3200
  )
3153
3201
  )
3154
3202
  ** 0.5,
3155
3203
  ) # [Nbatch, Nmask, Norient3, Norient2, Norient1]
3156
- ### Store C11 as a complex [Nbatch, Nmask, NC11, Norient3, Norient2, Norient1]
3157
- if C11 is None:
3158
- C11 = self.backend.bk_expand_dims(
3159
- c11, off_C11
3160
- ) # Add a dimension for NC11
3204
+ ### Store S4 as a complex [Nbatch, Nmask, NS4, Norient3, Norient2, Norient1]
3205
+ if S4 is None:
3206
+ S4 = self.backend.bk_expand_dims(
3207
+ s4, off_S4
3208
+ ) # Add a dimension for NS4
3161
3209
  if calc_var:
3162
- VC11 = self.backend.bk_expand_dims(
3163
- vc11, off_C11
3164
- ) # Add a dimension for NC11
3210
+ VS4 = self.backend.bk_expand_dims(
3211
+ vs4, off_S4
3212
+ ) # Add a dimension for NS4
3165
3213
  else:
3166
- C11 = self.backend.bk_concat(
3167
- [C11, self.backend.bk_expand_dims(c11, off_C11)],
3214
+ S4 = self.backend.bk_concat(
3215
+ [S4, self.backend.bk_expand_dims(s4, off_S4)],
3168
3216
  axis=2,
3169
- ) # Add a dimension for NC11
3217
+ ) # Add a dimension for NS4
3170
3218
  if calc_var:
3171
- VC11 = self.backend.bk_concat(
3219
+ VS4 = self.backend.bk_concat(
3172
3220
  [
3173
- VC11,
3174
- self.backend.bk_expand_dims(vc11, off_C11),
3221
+ VS4,
3222
+ self.backend.bk_expand_dims(vs4, off_S4),
3175
3223
  ],
3176
3224
  axis=2,
3177
- ) # Add a dimension for NC11
3225
+ ) # Add a dimension for NS4
3178
3226
 
3179
- ### C11_cross = <(|I1 * psi1| * psi3)(|I2 * psi2| * psi3)^*>
3227
+ ### S4_cross = <(|I1 * psi1| * psi3)(|I2 * psi2| * psi3)^*>
3180
3228
  else:
3181
3229
  if calc_var:
3182
- c11, vc11 = self._compute_C11(
3230
+ s4, vs4 = self._compute_S4(
3183
3231
  j1,
3184
3232
  j2,
3185
3233
  vmask,
@@ -3188,7 +3236,7 @@ class funct(FOC.FoCUS):
3188
3236
  calc_var=True,
3189
3237
  ) # [Nbatch, Nmask, Norient3, Norient2, Norient1]
3190
3238
  else:
3191
- c11 = self._compute_C11(
3239
+ s4 = self._compute_S4(
3192
3240
  j1,
3193
3241
  j2,
3194
3242
  vmask,
@@ -3198,52 +3246,52 @@ class funct(FOC.FoCUS):
3198
3246
  ) # [Nbatch, Nmask, Norient3, Norient2, Norient1]
3199
3247
 
3200
3248
  if return_data:
3201
- if C11[j3][j2] is None:
3202
- C11[j3][j2] = {}
3203
- C11[j3][j2][j1] = c11
3249
+ if S4[j3][j2] is None:
3250
+ S4[j3][j2] = {}
3251
+ S4[j3][j2][j1] = s4
3204
3252
  else:
3205
- ### Normalize C11 with P00_j [Nbatch, Nmask, Norient_j]
3253
+ ### Normalize S4 with S2_j [Nbatch, Nmask, Norient_j]
3206
3254
  if norm is not None:
3207
3255
  self.div_norm(
3208
- c11,
3256
+ s4,
3209
3257
  (
3210
3258
  self.backend.bk_expand_dims(
3211
3259
  self.backend.bk_expand_dims(
3212
- P1_dic[j1], off_P0
3260
+ P1_dic[j1], off_S2
3213
3261
  ),
3214
- off_P0,
3262
+ off_S2,
3215
3263
  )
3216
3264
  * self.backend.bk_expand_dims(
3217
3265
  self.backend.bk_expand_dims(
3218
- P2_dic[j2], off_P0
3266
+ P2_dic[j2], off_S2
3219
3267
  ),
3220
3268
  -1,
3221
3269
  )
3222
3270
  )
3223
3271
  ** 0.5,
3224
3272
  ) # [Nbatch, Nmask, Norient3, Norient2, Norient1]
3225
- ### Store C11 as a complex [Nbatch, Nmask, NC11, Norient3, Norient2, Norient1]
3226
- if C11 is None:
3227
- C11 = self.backend.bk_expand_dims(
3228
- c11, off_C11
3229
- ) # Add a dimension for NC11
3273
+ ### Store S4 as a complex [Nbatch, Nmask, NS4, Norient3, Norient2, Norient1]
3274
+ if S4 is None:
3275
+ S4 = self.backend.bk_expand_dims(
3276
+ s4, off_S4
3277
+ ) # Add a dimension for NS4
3230
3278
  if calc_var:
3231
- VC11 = self.backend.bk_expand_dims(
3232
- vc11, off_C11
3233
- ) # Add a dimension for NC11
3279
+ VS4 = self.backend.bk_expand_dims(
3280
+ vs4, off_S4
3281
+ ) # Add a dimension for NS4
3234
3282
  else:
3235
- C11 = self.backend.bk_concat(
3236
- [C11, self.backend.bk_expand_dims(c11, off_C11)],
3283
+ S4 = self.backend.bk_concat(
3284
+ [S4, self.backend.bk_expand_dims(s4, off_S4)],
3237
3285
  axis=2,
3238
- ) # Add a dimension for NC11
3286
+ ) # Add a dimension for NS4
3239
3287
  if calc_var:
3240
- VC11 = self.backend.bk_concat(
3288
+ VS4 = self.backend.bk_concat(
3241
3289
  [
3242
- VC11,
3243
- self.backend.bk_expand_dims(vc11, off_C11),
3290
+ VS4,
3291
+ self.backend.bk_expand_dims(vs4, off_S4),
3244
3292
  ],
3245
3293
  axis=2,
3246
- ) # Add a dimension for NC11
3294
+ ) # Add a dimension for NS4
3247
3295
 
3248
3296
  ###### Reshape for next iteration on j3
3249
3297
  ### Image I1,
@@ -3293,12 +3341,12 @@ class funct(FOC.FoCUS):
3293
3341
  if calc_var:
3294
3342
  if not cross:
3295
3343
  return scat_cov(
3296
- s0, P00, C01, C11, s1=S1, backend=self.backend, use_1D=self.use_1D
3344
+ s0, S2, S3, S4, s1=S1, backend=self.backend, use_1D=self.use_1D
3297
3345
  ), scat_cov(
3298
3346
  vs0,
3299
- VP00,
3300
- VC01,
3301
- VC11,
3347
+ VS2,
3348
+ VS3,
3349
+ VS4,
3302
3350
  s1=VS1,
3303
3351
  backend=self.backend,
3304
3352
  use_1D=self.use_1D,
@@ -3306,36 +3354,36 @@ class funct(FOC.FoCUS):
3306
3354
  else:
3307
3355
  return scat_cov(
3308
3356
  s0,
3309
- P00,
3310
- C01,
3311
- C11,
3357
+ S2,
3358
+ S3,
3359
+ S4,
3312
3360
  s1=S1,
3313
- c10=C10,
3361
+ s3p=S3P,
3314
3362
  backend=self.backend,
3315
3363
  use_1D=self.use_1D,
3316
3364
  ), scat_cov(
3317
3365
  vs0,
3318
- VP00,
3319
- VC01,
3320
- VC11,
3366
+ VS2,
3367
+ VS3,
3368
+ VS4,
3321
3369
  s1=VS1,
3322
- c10=VC10,
3370
+ s3p=VS3P,
3323
3371
  backend=self.backend,
3324
3372
  use_1D=self.use_1D,
3325
3373
  )
3326
3374
  else:
3327
3375
  if not cross:
3328
3376
  return scat_cov(
3329
- s0, P00, C01, C11, s1=S1, backend=self.backend, use_1D=self.use_1D
3377
+ s0, S2, S3, S4, s1=S1, backend=self.backend, use_1D=self.use_1D
3330
3378
  )
3331
3379
  else:
3332
3380
  return scat_cov(
3333
3381
  s0,
3334
- P00,
3335
- C01,
3336
- C11,
3382
+ S2,
3383
+ S3,
3384
+ S4,
3337
3385
  s1=S1,
3338
- c10=C10,
3386
+ s3p=S3P,
3339
3387
  backend=self.backend,
3340
3388
  use_1D=self.use_1D,
3341
3389
  )
@@ -3345,7 +3393,7 @@ class funct(FOC.FoCUS):
3345
3393
  self.P2_dic = None
3346
3394
  return
3347
3395
 
3348
- def _compute_C01(
3396
+ def _compute_S3(
3349
3397
  self,
3350
3398
  j2,
3351
3399
  j3,
@@ -3358,13 +3406,13 @@ class funct(FOC.FoCUS):
3358
3406
  cmat2=None,
3359
3407
  ):
3360
3408
  """
3361
- Compute the C01 coefficients (auto or cross)
3362
- C01 = < (Ia * Psi)_j3 x (|Ib * Psi_j2| * Psi_j3)^* >_pix
3409
+ Compute the S3 coefficients (auto or cross)
3410
+ S3 = < (Ia * Psi)_j3 x (|Ib * Psi_j2| * Psi_j3)^* >_pix
3363
3411
  Parameters
3364
3412
  ----------
3365
3413
  Returns
3366
3414
  -------
3367
- cc01, sc01: real and imag parts of C01 coeff
3415
+ cs3, ss3: real and imag parts of S3 coeff
3368
3416
  """
3369
3417
  ### Compute |I1 * Psi_j2| * Psi_j3 = M1_j2 * Psi_j3
3370
3418
  # Warning: M1_dic[j2] is already at j3 resolution [Nbatch, Npix_j3, Norient3]
@@ -3375,40 +3423,40 @@ class funct(FOC.FoCUS):
3375
3423
  tmp2 = self.backend.bk_repeat(MconvPsi, 4, axis=-1)
3376
3424
  MconvPsi = self.backend.bk_reduce_sum(
3377
3425
  self.backend.bk_reshape(
3378
- cmat2[j3][j2] * tmp2, [1, cmat2[j3].shape[1], 4, 4, 4]
3426
+ cmat2[j3][j2] * tmp2, [tmp2.shape[0], cmat2[j3].shape[1], 4, 4, 4]
3379
3427
  ),
3380
3428
  3,
3381
3429
  )
3382
3430
 
3383
- # Store it so we can use it in C11 computation
3431
+ # Store it so we can use it in S4 computation
3384
3432
  MconvPsi_dic[j2] = MconvPsi # [Nbatch, Npix_j3, Norient3, Norient2]
3385
3433
 
3386
3434
  ### Compute the product (I2 * Psi)_j3 x (M1_j2 * Psi_j3)^*
3387
3435
  # z_1 x z_2^* = (a1a2 + b1b2) + i(b1a2 - a1b2)
3388
3436
  # cconv, sconv are [Nbatch, Npix_j3, Norient3]
3389
3437
  if self.use_1D:
3390
- c01 = conv * self.backend.bk_conjugate(MconvPsi)
3438
+ s3 = conv * self.backend.bk_conjugate(MconvPsi)
3391
3439
  else:
3392
- c01 = self.backend.bk_expand_dims(conv, -1) * self.backend.bk_conjugate(
3440
+ s3 = self.backend.bk_expand_dims(conv, -1) * self.backend.bk_conjugate(
3393
3441
  MconvPsi
3394
3442
  ) # [Nbatch, Npix_j3, Norient3, Norient2]
3395
3443
 
3396
3444
  ### Apply the mask [Nmask, Npix_j3] and sum over pixels
3397
3445
  if return_data:
3398
- return c01
3446
+ return s3
3399
3447
  else:
3400
3448
  if calc_var:
3401
- c01, vc01 = self.masked_mean(
3402
- c01, vmask, axis=1, rank=j2, calc_var=True
3449
+ s3, vs3 = self.masked_mean(
3450
+ s3, vmask, axis=1, rank=j2, calc_var=True
3403
3451
  ) # [Nbatch, Nmask, Norient3, Norient2]
3404
- return c01, vc01
3452
+ return s3, vs3
3405
3453
  else:
3406
- c01 = self.masked_mean(
3407
- c01, vmask, axis=1, rank=j2
3454
+ s3 = self.masked_mean(
3455
+ s3, vmask, axis=1, rank=j2
3408
3456
  ) # [Nbatch, Nmask, Norient3, Norient2]
3409
- return c01
3457
+ return s3
3410
3458
 
3411
- def _compute_C11(
3459
+ def _compute_S4(
3412
3460
  self,
3413
3461
  j1,
3414
3462
  j2,
@@ -3430,44 +3478,44 @@ class funct(FOC.FoCUS):
3430
3478
  ### Compute the product (|I1 * Psi_j1| * Psi_j3)(|I2 * Psi_j2| * Psi_j3)
3431
3479
  # z_1 x z_2^* = (a1a2 + b1b2) + i(b1a2 - a1b2)
3432
3480
  if self.use_1D:
3433
- c11 = M1 * self.backend.bk_conjugate(M2)
3481
+ s4 = M1 * self.backend.bk_conjugate(M2)
3434
3482
  else:
3435
- c11 = self.backend.bk_expand_dims(M1, -2) * self.backend.bk_conjugate(
3483
+ s4 = self.backend.bk_expand_dims(M1, -2) * self.backend.bk_conjugate(
3436
3484
  self.backend.bk_expand_dims(M2, -1)
3437
3485
  ) # [Nbatch, Npix_j3, Norient3, Norient2, Norient1]
3438
3486
 
3439
3487
  ### Apply the mask and sum over pixels
3440
3488
  if return_data:
3441
- return c11
3489
+ return s4
3442
3490
  else:
3443
3491
  if calc_var:
3444
- c11, vc11 = self.masked_mean(
3445
- c11, vmask, axis=1, rank=j2, calc_var=True
3492
+ s4, vs4 = self.masked_mean(
3493
+ s4, vmask, axis=1, rank=j2, calc_var=True
3446
3494
  ) # [Nbatch, Nmask, Norient3, Norient2, Norient1]
3447
- return c11, vc11
3495
+ return s4, vs4
3448
3496
  else:
3449
- c11 = self.masked_mean(
3450
- c11, vmask, axis=1, rank=j2
3497
+ s4 = self.masked_mean(
3498
+ s4, vmask, axis=1, rank=j2
3451
3499
  ) # [Nbatch, Nmask, Norient3, Norient2, Norient1]
3452
- return c11
3500
+ return s4
3453
3501
 
3454
3502
  def square(self, x):
3455
3503
  if isinstance(x, scat_cov):
3456
3504
  if x.S1 is None:
3457
3505
  return scat_cov(
3458
3506
  self.backend.bk_square(self.backend.bk_abs(x.S0)),
3459
- self.backend.bk_square(self.backend.bk_abs(x.P00)),
3460
- self.backend.bk_square(self.backend.bk_abs(x.C01)),
3461
- self.backend.bk_square(self.backend.bk_abs(x.C11)),
3507
+ self.backend.bk_square(self.backend.bk_abs(x.S2)),
3508
+ self.backend.bk_square(self.backend.bk_abs(x.S3)),
3509
+ self.backend.bk_square(self.backend.bk_abs(x.S4)),
3462
3510
  backend=self.backend,
3463
3511
  use_1D=self.use_1D,
3464
3512
  )
3465
3513
  else:
3466
3514
  return scat_cov(
3467
3515
  self.backend.bk_square(self.backend.bk_abs(x.S0)),
3468
- self.backend.bk_square(self.backend.bk_abs(x.P00)),
3469
- self.backend.bk_square(self.backend.bk_abs(x.C01)),
3470
- self.backend.bk_square(self.backend.bk_abs(x.C11)),
3516
+ self.backend.bk_square(self.backend.bk_abs(x.S2)),
3517
+ self.backend.bk_square(self.backend.bk_abs(x.S3)),
3518
+ self.backend.bk_square(self.backend.bk_abs(x.S4)),
3471
3519
  s1=self.backend.bk_square(self.backend.bk_abs(x.S1)),
3472
3520
  backend=self.backend,
3473
3521
  use_1D=self.use_1D,
@@ -3480,18 +3528,18 @@ class funct(FOC.FoCUS):
3480
3528
  if x.S1 is None:
3481
3529
  return scat_cov(
3482
3530
  self.backend.bk_sqrt(self.backend.bk_abs(x.S0)),
3483
- self.backend.bk_sqrt(self.backend.bk_abs(x.P00)),
3484
- self.backend.bk_sqrt(self.backend.bk_abs(x.C01)),
3485
- self.backend.bk_sqrt(self.backend.bk_abs(x.C11)),
3531
+ self.backend.bk_sqrt(self.backend.bk_abs(x.S2)),
3532
+ self.backend.bk_sqrt(self.backend.bk_abs(x.S3)),
3533
+ self.backend.bk_sqrt(self.backend.bk_abs(x.S4)),
3486
3534
  backend=self.backend,
3487
3535
  use_1D=self.use_1D,
3488
3536
  )
3489
3537
  else:
3490
3538
  return scat_cov(
3491
3539
  self.backend.bk_sqrt(self.backend.bk_abs(x.S0)),
3492
- self.backend.bk_sqrt(self.backend.bk_abs(x.P00)),
3493
- self.backend.bk_sqrt(self.backend.bk_abs(x.C01)),
3494
- self.backend.bk_sqrt(self.backend.bk_abs(x.C11)),
3540
+ self.backend.bk_sqrt(self.backend.bk_abs(x.S2)),
3541
+ self.backend.bk_sqrt(self.backend.bk_abs(x.S3)),
3542
+ self.backend.bk_sqrt(self.backend.bk_abs(x.S4)),
3495
3543
  s1=self.backend.bk_sqrt(self.backend.bk_abs(x.S1)),
3496
3544
  backend=self.backend,
3497
3545
  use_1D=self.use_1D,
@@ -3504,22 +3552,36 @@ class funct(FOC.FoCUS):
3504
3552
  if x.S1 is None:
3505
3553
  result = (
3506
3554
  self.backend.bk_reduce_mean(self.backend.bk_abs(x.S0))
3507
- + self.backend.bk_reduce_mean(self.backend.bk_abs(x.P00))
3508
- + self.backend.bk_reduce_mean(self.backend.bk_abs(x.C01))
3509
- + self.backend.bk_reduce_mean(self.backend.bk_abs(x.C11))
3555
+ + self.backend.bk_reduce_mean(self.backend.bk_abs(x.S2))
3556
+ + self.backend.bk_reduce_mean(self.backend.bk_abs(x.S3))
3557
+ + self.backend.bk_reduce_mean(self.backend.bk_abs(x.S4))
3510
3558
  ) / 3
3511
3559
  else:
3512
3560
  result = (
3513
3561
  self.backend.bk_reduce_mean(self.backend.bk_abs(x.S0))
3514
- + self.backend.bk_reduce_mean(self.backend.bk_abs(x.P00))
3562
+ + self.backend.bk_reduce_mean(self.backend.bk_abs(x.S2))
3515
3563
  + self.backend.bk_reduce_mean(self.backend.bk_abs(x.S1))
3516
- + self.backend.bk_reduce_mean(self.backend.bk_abs(x.C01))
3517
- + self.backend.bk_reduce_mean(self.backend.bk_abs(x.C11))
3564
+ + self.backend.bk_reduce_mean(self.backend.bk_abs(x.S3))
3565
+ + self.backend.bk_reduce_mean(self.backend.bk_abs(x.S4))
3518
3566
  ) / 4
3519
3567
  else:
3520
3568
  return self.backend.bk_reduce_mean(x)
3521
3569
  return result
3522
3570
 
3571
+ def reduce_mean_batch(self, x):
3572
+ if isinstance(x, scat_cov):
3573
+ result = scat_cov()
3574
+ # Assuming the batch dimension is the first dimension
3575
+ result.S0 = self.backend.bk_reduce_mean(x.S0, axis=0)
3576
+ result.S2 = self.backend.bk_reduce_mean(x.S2, axis=0)
3577
+ if x.S1 is not None:
3578
+ result.S1 = self.backend.bk_reduce_mean(x.S1, axis=0)
3579
+ result.S3 = self.backend.bk_reduce_mean(x.S3, axis=0)
3580
+ result.S4 = self.backend.bk_reduce_mean(x.S4, axis=0)
3581
+ return result
3582
+ else:
3583
+ return self.backend.bk_reduce_mean(x, axis=0)
3584
+
3523
3585
  def reduce_distance(self, x, y, sigma=None):
3524
3586
 
3525
3587
  if isinstance(x, scat_cov):
@@ -3527,30 +3589,30 @@ class funct(FOC.FoCUS):
3527
3589
  result = self.diff_data(y.S0, x.S0, is_complex=False)
3528
3590
  if x.S1 is not None:
3529
3591
  result += self.diff_data(y.S1, x.S1)
3530
- if x.C10 is not None:
3531
- result += self.diff_data(y.C10, x.C10)
3532
- result += self.diff_data(y.P00, x.P00)
3533
- result += self.diff_data(y.C01, x.C01)
3534
- result += self.diff_data(y.C11, x.C11)
3592
+ if x.S3P is not None:
3593
+ result += self.diff_data(y.S3P, x.S3P)
3594
+ result += self.diff_data(y.S2, x.S2)
3595
+ result += self.diff_data(y.S3, x.S3)
3596
+ result += self.diff_data(y.S4, x.S4)
3535
3597
  else:
3536
3598
  result = self.diff_data(y.S0, x.S0, is_complex=False, sigma=sigma.S0)
3537
3599
  if x.S1 is not None:
3538
3600
  result += self.diff_data(y.S1, x.S1, sigma=sigma.S1)
3539
- if x.C10 is not None:
3540
- result += self.diff_data(y.C10, x.C10, sigma=sigma.C10)
3541
- result += self.diff_data(y.P00, x.P00, sigma=sigma.P00)
3542
- result += self.diff_data(y.C01, x.C01, sigma=sigma.C01)
3543
- result += self.diff_data(y.C11, x.C11, sigma=sigma.C11)
3601
+ if x.S3P is not None:
3602
+ result += self.diff_data(y.S3P, x.S3P, sigma=sigma.S3P)
3603
+ result += self.diff_data(y.S2, x.S2, sigma=sigma.S2)
3604
+ result += self.diff_data(y.S3, x.S3, sigma=sigma.S3)
3605
+ result += self.diff_data(y.S4, x.S4, sigma=sigma.S4)
3544
3606
  nval = (
3545
3607
  self.backend.bk_size(x.S0)
3546
- + self.backend.bk_size(x.P00)
3547
- + self.backend.bk_size(x.C01)
3548
- + self.backend.bk_size(x.C11)
3608
+ + self.backend.bk_size(x.S2)
3609
+ + self.backend.bk_size(x.S3)
3610
+ + self.backend.bk_size(x.S4)
3549
3611
  )
3550
3612
  if x.S1 is not None:
3551
3613
  nval += self.backend.bk_size(x.S1)
3552
- if x.C10 is not None:
3553
- nval += self.backend.bk_size(x.C10)
3614
+ if x.S3P is not None:
3615
+ nval += self.backend.bk_size(x.S3P)
3554
3616
  result /= self.backend.bk_cast(nval)
3555
3617
  else:
3556
3618
  return self.backend.bk_reduce_sum(x)
@@ -3562,17 +3624,17 @@ class funct(FOC.FoCUS):
3562
3624
  if x.S1 is None:
3563
3625
  result = (
3564
3626
  self.backend.bk_reduce_sum(x.S0)
3565
- + self.backend.bk_reduce_sum(x.P00)
3566
- + self.backend.bk_reduce_sum(x.C01)
3567
- + self.backend.bk_reduce_sum(x.C11)
3627
+ + self.backend.bk_reduce_sum(x.S2)
3628
+ + self.backend.bk_reduce_sum(x.S3)
3629
+ + self.backend.bk_reduce_sum(x.S4)
3568
3630
  )
3569
3631
  else:
3570
3632
  result = (
3571
3633
  self.backend.bk_reduce_sum(x.S0)
3572
- + self.backend.bk_reduce_sum(x.P00)
3634
+ + self.backend.bk_reduce_sum(x.S2)
3573
3635
  + self.backend.bk_reduce_sum(x.S1)
3574
- + self.backend.bk_reduce_sum(x.C01)
3575
- + self.backend.bk_reduce_sum(x.C11)
3636
+ + self.backend.bk_reduce_sum(x.S3)
3637
+ + self.backend.bk_reduce_sum(x.S4)
3576
3638
  )
3577
3639
  else:
3578
3640
  return self.backend.bk_reduce_sum(x)
@@ -3581,43 +3643,43 @@ class funct(FOC.FoCUS):
3581
3643
  def ldiff(self, sig, x):
3582
3644
 
3583
3645
  if x.S1 is None:
3584
- if x.C10 is not None:
3646
+ if x.S3P is not None:
3585
3647
  return scat_cov(
3586
3648
  x.domult(sig.S0, x.S0) * x.domult(sig.S0, x.S0),
3587
- x.domult(sig.P00, x.P00) * x.domult(sig.P00, x.P00),
3588
- x.domult(sig.C01, x.C01) * x.domult(sig.C01, x.C01),
3589
- x.domult(sig.C11, x.C11) * x.domult(sig.C11, x.C11),
3590
- C10=x.domult(sig.C10, x.C10) * x.domult(sig.C10, x.C10),
3649
+ x.domult(sig.S2, x.S2) * x.domult(sig.S2, x.S2),
3650
+ x.domult(sig.S3, x.S3) * x.domult(sig.S3, x.S3),
3651
+ x.domult(sig.S4, x.S4) * x.domult(sig.S4, x.S4),
3652
+ S3P=x.domult(sig.S3P, x.S3P) * x.domult(sig.S3P, x.S3P),
3591
3653
  backend=self.backend,
3592
3654
  use_1D=self.use_1D,
3593
3655
  )
3594
3656
  else:
3595
3657
  return scat_cov(
3596
3658
  x.domult(sig.S0, x.S0) * x.domult(sig.S0, x.S0),
3597
- x.domult(sig.P00, x.P00) * x.domult(sig.P00, x.P00),
3598
- x.domult(sig.C01, x.C01) * x.domult(sig.C01, x.C01),
3599
- x.domult(sig.C11, x.C11) * x.domult(sig.C11, x.C11),
3659
+ x.domult(sig.S2, x.S2) * x.domult(sig.S2, x.S2),
3660
+ x.domult(sig.S3, x.S3) * x.domult(sig.S3, x.S3),
3661
+ x.domult(sig.S4, x.S4) * x.domult(sig.S4, x.S4),
3600
3662
  backend=self.backend,
3601
3663
  use_1D=self.use_1D,
3602
3664
  )
3603
3665
  else:
3604
- if x.C10 is None:
3666
+ if x.S3P is None:
3605
3667
  return scat_cov(
3606
3668
  x.domult(sig.S0, x.S0) * x.domult(sig.S0, x.S0),
3607
- x.domult(sig.P00, x.P00) * x.domult(sig.P00, x.P00),
3608
- x.domult(sig.C01, x.C01) * x.domult(sig.C01, x.C01),
3609
- x.domult(sig.C11, x.C11) * x.domult(sig.C11, x.C11),
3669
+ x.domult(sig.S2, x.S2) * x.domult(sig.S2, x.S2),
3670
+ x.domult(sig.S3, x.S3) * x.domult(sig.S3, x.S3),
3671
+ x.domult(sig.S4, x.S4) * x.domult(sig.S4, x.S4),
3610
3672
  S1=x.domult(sig.S1, x.S1) * x.domult(sig.S1, x.S1),
3611
- C10=x.domult(sig.C10, x.C10) * x.domult(sig.C10, x.C10),
3673
+ S3P=x.domult(sig.S3P, x.S3P) * x.domult(sig.S3P, x.S3P),
3612
3674
  backend=self.backend,
3613
3675
  use_1D=self.use_1D,
3614
3676
  )
3615
3677
  else:
3616
3678
  return scat_cov(
3617
3679
  x.domult(sig.S0, x.S0) * x.domult(sig.S0, x.S0),
3618
- x.domult(sig.P00, x.P00) * x.domult(sig.P00, x.P00),
3619
- x.domult(sig.C01, x.C01) * x.domult(sig.C01, x.C01),
3620
- x.domult(sig.C11, x.C11) * x.domult(sig.C11, x.C11),
3680
+ x.domult(sig.S2, x.S2) * x.domult(sig.S2, x.S2),
3681
+ x.domult(sig.S3, x.S3) * x.domult(sig.S3, x.S3),
3682
+ x.domult(sig.S4, x.S4) * x.domult(sig.S4, x.S4),
3621
3683
  S1=x.domult(sig.S1, x.S1) * x.domult(sig.S1, x.S1),
3622
3684
  backend=self.backend,
3623
3685
  use_1D=self.use_1D,
@@ -3629,73 +3691,73 @@ class funct(FOC.FoCUS):
3629
3691
  if x.S1 is None:
3630
3692
  result = (
3631
3693
  self.backend.bk_log(x.S0)
3632
- + self.backend.bk_log(x.P00)
3633
- + self.backend.bk_log(x.C01)
3634
- + self.backend.bk_log(x.C11)
3694
+ + self.backend.bk_log(x.S2)
3695
+ + self.backend.bk_log(x.S3)
3696
+ + self.backend.bk_log(x.S4)
3635
3697
  )
3636
3698
  else:
3637
3699
  result = (
3638
3700
  self.backend.bk_log(x.S0)
3639
- + self.backend.bk_log(x.P00)
3701
+ + self.backend.bk_log(x.S2)
3640
3702
  + self.backend.bk_log(x.S1)
3641
- + self.backend.bk_log(x.C01)
3642
- + self.backend.bk_log(x.C11)
3703
+ + self.backend.bk_log(x.S3)
3704
+ + self.backend.bk_log(x.S4)
3643
3705
  )
3644
3706
  else:
3645
3707
  return self.backend.bk_log(x)
3646
3708
 
3647
3709
  return result
3648
3710
 
3649
- # # ---------------------------------------------−---------
3650
- # def std(self, list_of_sc):
3651
- # n = len(list_of_sc)
3652
- # res = list_of_sc[0]
3653
- # res2 = list_of_sc[0] * list_of_sc[0]
3654
- # for k in range(1, n):
3655
- # res = res + list_of_sc[k]
3656
- # res2 = res2 + list_of_sc[k] * list_of_sc[k]
3657
- #
3658
- # if res.S1 is None:
3659
- # if res.C10 is not None:
3660
- # return scat_cov(
3661
- # res.domult(sig.S0, res.S0) * res.domult(sig.S0, res.S0),
3662
- # res.domult(sig.P00, res.P00) * res.domult(sig.P00, res.P00),
3663
- # res.domult(sig.C01, res.C01) * res.domult(sig.C01, res.C01),
3664
- # res.domult(sig.C11, res.C11) * res.domult(sig.C11, res.C11),
3665
- # C10=res.domult(sig.C10, res.C10) * res.domult(sig.C10, res.C10),
3666
- # backend=self.backend,
3667
- # use_1D=self.use_1D,
3668
- # )
3669
- # else:
3670
- # return scat_cov(
3671
- # res.domult(sig.S0, res.S0) * res.domult(sig.S0, res.S0),
3672
- # res.domult(sig.P00, res.P00) * res.domult(sig.P00, res.P00),
3673
- # res.domult(sig.C01, res.C01) * res.domult(sig.C01, res.C01),
3674
- # res.domult(sig.C11, res.C11) * res.domult(sig.C11, res.C11),
3675
- # backend=self.backend,
3676
- # use_1D=self.use_1D,
3677
- # )
3678
- # else:
3679
- # if res.C10 is None:
3680
- # return scat_cov(
3681
- # res.domult(sig.S0, res.S0) * res.domult(sig.S0, res.S0),
3682
- # res.domult(sig.P00, res.P00) * res.domult(sig.P00, res.P00),
3683
- # res.domult(sig.C01, res.C01) * res.domult(sig.C01, res.C01),
3684
- # res.domult(sig.C11, res.C11) * res.domult(sig.C11, res.C11),
3685
- # S1=res.domult(sig.S1, res.S1) * res.domult(sig.S1, res.S1),
3686
- # C10=res.domult(sig.C10, res.C10) * res.domult(sig.C10, res.C10),
3687
- # backend=self.backend,
3688
- # )
3689
- # else:
3690
- # return scat_cov(
3691
- # res.domult(sig.P00, res.P00) * res.domult(sig.P00, res.P00),
3692
- # res.domult(sig.S1, res.S1) * res.domult(sig.S1, res.S1),
3693
- # res.domult(sig.C01, res.C01) * res.domult(sig.C01, res.C01),
3694
- # res.domult(sig.C11, res.C11) * res.domult(sig.C11, res.C11),
3695
- # backend=self.backend,
3696
- # use_1D=self.use_1D,
3697
- # )
3698
- # return self.NORIENT
3711
+ # # ---------------------------------------------−---------
3712
+ # def std(self, list_of_sc):
3713
+ # n = len(list_of_sc)
3714
+ # res = list_of_sc[0]
3715
+ # res2 = list_of_sc[0] * list_of_sc[0]
3716
+ # for k in range(1, n):
3717
+ # res = res + list_of_sc[k]
3718
+ # res2 = res2 + list_of_sc[k] * list_of_sc[k]
3719
+ #
3720
+ # if res.S1 is None:
3721
+ # if res.S3P is not None:
3722
+ # return scat_cov(
3723
+ # res.domult(sig.S0, res.S0) * res.domult(sig.S0, res.S0),
3724
+ # res.domult(sig.S2, res.S2) * res.domult(sig.S2, res.S2),
3725
+ # res.domult(sig.S3, res.S3) * res.domult(sig.S3, res.S3),
3726
+ # res.domult(sig.S4, res.S4) * res.domult(sig.S4, res.S4),
3727
+ # S3P=res.domult(sig.S3P, res.S3P) * res.domult(sig.S3P, res.S3P),
3728
+ # backend=self.backend,
3729
+ # use_1D=self.use_1D,
3730
+ # )
3731
+ # else:
3732
+ # return scat_cov(
3733
+ # res.domult(sig.S0, res.S0) * res.domult(sig.S0, res.S0),
3734
+ # res.domult(sig.S2, res.S2) * res.domult(sig.S2, res.S2),
3735
+ # res.domult(sig.S3, res.S3) * res.domult(sig.S3, res.S3),
3736
+ # res.domult(sig.S4, res.S4) * res.domult(sig.S4, res.S4),
3737
+ # backend=self.backend,
3738
+ # use_1D=self.use_1D,
3739
+ # )
3740
+ # else:
3741
+ # if res.S3P is None:
3742
+ # return scat_cov(
3743
+ # res.domult(sig.S0, res.S0) * res.domult(sig.S0, res.S0),
3744
+ # res.domult(sig.S2, res.S2) * res.domult(sig.S2, res.S2),
3745
+ # res.domult(sig.S3, res.S3) * res.domult(sig.S3, res.S3),
3746
+ # res.domult(sig.S4, res.S4) * res.domult(sig.S4, res.S4),
3747
+ # S1=res.domult(sig.S1, res.S1) * res.domult(sig.S1, res.S1),
3748
+ # S3P=res.domult(sig.S3P, res.S3P) * res.domult(sig.S3P, res.S3P),
3749
+ # backend=self.backend,
3750
+ # )
3751
+ # else:
3752
+ # return scat_cov(
3753
+ # res.domult(sig.S2, res.S2) * res.domult(sig.S2, res.S2),
3754
+ # res.domult(sig.S1, res.S1) * res.domult(sig.S1, res.S1),
3755
+ # res.domult(sig.S3, res.S3) * res.domult(sig.S3, res.S3),
3756
+ # res.domult(sig.S4, res.S4) * res.domult(sig.S4, res.S4),
3757
+ # backend=self.backend,
3758
+ # use_1D=self.use_1D,
3759
+ # )
3760
+ # return self.NORIENT
3699
3761
 
3700
3762
  @tf_function
3701
3763
  def eval_comp_fast(
@@ -3712,7 +3774,7 @@ class funct(FOC.FoCUS):
3712
3774
  res = self.eval(
3713
3775
  image1, image2=image2, mask=mask, Auto=Auto, cmat=cmat, cmat2=cmat2
3714
3776
  )
3715
- return res.S0, res.P00, res.S1, res.C01, res.C11, res.C10
3777
+ return res.S0, res.S2, res.S1, res.S3, res.S4, res.S3P
3716
3778
 
3717
3779
  def eval_fast(
3718
3780
  self,
@@ -3724,9 +3786,9 @@ class funct(FOC.FoCUS):
3724
3786
  cmat=None,
3725
3787
  cmat2=None,
3726
3788
  ):
3727
- s0, p0, s1, c01, c11, c10 = self.eval_comp_fast(
3789
+ s0, s2, s1, s3, s4, s3p = self.eval_comp_fast(
3728
3790
  image1, image2=image2, mask=mask, Auto=Auto, cmat=cmat, cmat2=cmat2
3729
3791
  )
3730
3792
  return scat_cov(
3731
- s0, p0, c01, c11, s1=s1, c10=c10, backend=self.backend, use_1D=self.use_1D
3793
+ s0, s2, s3, s4, s1=s1, s3p=s3p, backend=self.backend, use_1D=self.use_1D
3732
3794
  )