xrt 1.5.0__zip → 1.6.1__zip

{xrt-1.5.0 → xrt-1.6.1}/xrt/backends/raycing/sources_synchr.py

@@ -159,11 +159,11 @@ class BendingMagnet(SourceBase):
 
         bo = None
         length = 0
-        seeded = np.long(0)
+        seeded = np.int64(0)
         seededI = 0.
         np.seterr(invalid='warn')
         np.seterr(divide='warn')
-        mcRays = np.long(self.nrays * 1.2) if not self.uniformRayDensity else\
+        mcRays = np.int64(self.nrays * 1.2) if not self.uniformRayDensity else\
             self.nrays
         if self.filamentBeam:
             if accuBeam is None:
@@ -367,7 +367,7 @@ class BendingMagnet(SourceBase):
             bo.seeded = seeded
             bo.seededI = seededI
         if length > self.nrays and not self.filamentBeam:
-            bo.filter_by_index(slice(0, np.long(self.nrays)))
+            bo.filter_by_index(slice(0, np.int64(self.nrays)))
         if self.filamentBeam:
             bo.filamentDtheta = dtheta
             bo.filamentDpsi = dpsi
@@ -564,6 +564,7 @@ class SourceFromField(IntegratedSource):
         return '5-SFF-xrt'
 
     def read_custom_field(self, fname, kwargs={}):
+        print(f'reading custom field from {fname}')
         if fname.endswith('.xls') or fname.endswith('.xlsx'):
             from pandas import read_excel
             data = read_excel(fname, **kwargs).values
@@ -683,7 +684,8 @@ class SourceFromField(IntegratedSource):
         rloc = np.array([trajx_, trajy_, trajz_])
 
         if R0 is not None:
-            R0 = np.expand_dims(R0, axis=1)
+            if len(R0.shape) < 2:
+                R0 = np.expand_dims(R0, 1)
             dr = R0 - rloc
             dist = np.linalg.norm(dr, axis=0)
             sinr0z = np.sin(wc*R0[2, :])
@@ -744,8 +746,8 @@ class SourceFromField(IntegratedSource):
     def _sp_sum(self, emcg, w, gamma, ddphi, ddpsi, Bx, By, Bz,
                 betax, betay, betam, trajx, trajy, trajz, R0=None):
 
-        Bsr = np.complex(0)
-        Bpr = np.complex(0)
+        Bsr = np.complex128(0)
+        Bpr = np.complex128(0)
 
         gamma_ = gamma[0] if self.filamentBeam else gamma
         dirx = ddphi
@@ -776,7 +778,9 @@ class SourceFromField(IntegratedSource):
 
             if R0 is not None:
                 rloc = np.array([trajx_, trajy_, trajz_])
-                dr = R0 - np.expand_dims(rloc, 1)
+                if len(rloc.shape) < 2:
+                    rloc = np.expand_dims(rloc, 1)
+                dr = R0 - rloc
                 dist = np.linalg.norm(dr, axis=0)
                 rdrz = 1./dr[2, :]
                 drs = (dr[0, :]**2+dr[1, :]**2)*rdrz
@@ -1157,14 +1161,20 @@ class SourceFromField(IntegratedSource):
                 self.build_trajectory_periodic(Bx, By, Bz)
             Bxt, Byt, Bzt = self._magnetic_field_periodic(self.tg)
 
-        self.beta = [betax, betay]
-        self.trajectory = [trajx, trajy, trajz]
-
         betam = betazav[-1]
         ab = 0.5 / np.pi / betam if self.filamentBeam else\
             0.5 / np.pi / (1. - 0.5/gamma**2 + betam*EMC**2/gamma**2)
         emcg = SIE0 / SIM0 / C / 10. / gamma
 
+        if self.filamentBeam:
+            self.beta = [betax, betay]
+            self.trajectory = [trajx, trajy, trajz]
+        else:
+            self.beta = [betax*emcg[0], betay*emcg[0]]
+            self.trajectory = [
+                trajx*emcg[0], trajy*emcg[0],
+                self.tg*(1.-0.5/gamma[0]**2) + trajz*EMC**2/gamma[0]**2]
+
         if self.R0:
             R0v = np.array(
                 (np.tan(ddtheta), np.tan(ddpsi), np.ones_like(ddpsi)))
@@ -1276,6 +1286,8 @@ class Undulator(IntegratedSource):
         else:
             self.taper = None
 
+        self.Kbase = True
+
         if Kx == 0 and Ky == 0:
             if abs(K) > 0:
                 self.Kx = 0
@@ -1283,8 +1295,9 @@ class Undulator(IntegratedSource):
             elif B0x == 0 and B0y == 0:
                 self.Kx = 0
                 self.K = 1
-                raise("Please define either K or B0!")
+                raise ValueError("Please define either K or B0!")
             else:
+                self.Kbase = False
                 self.B0y = B0y
                 self.B0x = B0x
         else:
@@ -1327,6 +1340,14 @@ class Undulator(IntegratedSource):
     @period.setter
     def period(self, period):
         self.L0 = float(period)
+        if hasattr(self, 'Kbase'):
+            if self.Kbase:
+                self._B0x = K2B * self.Kx / self.L0
+                self._B0y = K2B * self.Ky / self.L0
+            else:
+                self._Kx = self.B0x * self.L0 / K2B
+                self._Ky = self.B0y * self.L0 / K2B
+        self.report_E1()
         self.needReset = True
         # Need to recalculate the integration parameters
 
@@ -1363,6 +1384,7 @@ class Undulator(IntegratedSource):
                     print("Kx = Ky = {0}".format(Kx))
         self._Kx = Kx
         self._Ky = Ky
+        self.report_E1()
         self.needReset = True
         # Need to recalculate the integration parameters
 
@@ -1374,6 +1396,8 @@ class Undulator(IntegratedSource):
     def Kx(self, Kx):
         self._Kx = float(Kx)
         self._B0x = K2B * Kx / self.L0
+        if hasattr(self, '_Ky'):
+            self.report_E1()
         self.needReset = True
         # Need to recalculate the integration parameters
 
@@ -1386,7 +1410,8 @@ class Undulator(IntegratedSource):
         self._Ky = float(Ky)
         self._K = float(Ky)
         self._B0y = K2B * Ky / self.L0
-        self.report_E1()
+        if hasattr(self, '_Kx'):
+            self.report_E1()
         self.needReset = True
         # Need to recalculate the integration parameters
 
@@ -1398,7 +1423,8 @@ class Undulator(IntegratedSource):
     def K(self, K):
         self._Ky = float(K)
         self._B0y = K2B * K / self.L0
-        self.report_E1()
+        if hasattr(self, '_Kx'):
+            self.report_E1()
         self.needReset = True
         # Need to recalculate the integration parameters
 
@@ -1410,6 +1436,8 @@ class Undulator(IntegratedSource):
     def B0x(self, B0x):
         self._B0x = float(B0x)
         self._Kx = B0x * self.L0 / K2B
+        if hasattr(self, '_Ky'):
+            self.report_E1()
         self.needReset = True
         # Need to recalculate the integration parameters
 
@@ -1421,6 +1449,8 @@ class Undulator(IntegratedSource):
     def B0y(self, B0y):
         self._B0y = float(B0y)
         self._Ky = B0y * self.L0 / K2B
+        if hasattr(self, '_Kx'):
+            self.report_E1()
         self.needReset = True
         # Need to recalculate the integration parameters
 
@@ -1429,10 +1459,13 @@ class Undulator(IntegratedSource):
             (2*self.gamma2 - 1. - 0.5*self.Kx**2 - 0.5*self.Ky**2) / E2WC
 
         E1 = 2*wu*self.gamma2 / (1 + 0.5*self.Kx**2 + 0.5*self.Ky**2)
-        if raycing._VERBOSITY_ > 10:
-
+        if raycing._VERBOSITY_ >= 10:
             print("E1 = {0}".format(E1))
-            print("E3 = {0}".format(3*E1))
+            print("E3 = {0}".format(E1*3))
+            print("E5 = {0}".format(E1*5))
+            print("E7 = {0}".format(E1*7))
+            print("E9 = {0}".format(E1*9))
+            print("E11 = {0}".format(E1*11))
             print("B0 = {0}".format(self.B0y))
             if self.taper is not None:
                 print("dB/dx/B = {0}".format(
@@ -1450,8 +1483,8 @@ class Undulator(IntegratedSource):
         given K values (*Ks*). The flux is calculated through the aperture
         defined by *theta* and *psi* opening angles (1D arrays).
 
-        Returns two 2D arrays: energy positions and flux values. The rows
-        correspond to *Ks*, the colums correspond to *harmomonics*.
+        Returns two 2D arrays: energy in keV and flux values in ph/s/0.1%bw.
+        The rows correspond to *Ks*, the colums correspond to *harmomonics*.
         """
         try:
             dtheta, dpsi = theta[1] - theta[0], psi[1] - psi[0]
@@ -1460,11 +1493,25 @@ class Undulator(IntegratedSource):
         tunesE, tunesF = [], []
         tmpKy = self.Ky
         for iK, K in enumerate(Ks):
-            if raycing._VERBOSITY_ > 10:
-                print("K={0}, {1} of {2}".format(K, iK+1, len(Ks)))
+            if raycing._VERBOSITY_ >= 10:
+                print("\nCalculation {1} of {2}, K={0:.3f}".format(
+                    K, iK+1, len(Ks)))
             self.Ky = K
-            I0 = self.intensities_on_mesh(energy, theta, psi, harmonics)[0]
-            flux = I0.sum(axis=(1, 2)) * dtheta * dpsi
+            # all energies can be calculated at once but for big theta and psi
+            # arrays the I0 array may become too big to fit into memory:
+            # I0 = self.intensities_on_mesh(energy, theta, psi, harmonics)[0]
+            # flux = I0.sum(axis=(1, 2)) * dtheta * dpsi
+            # therefore, energy axis is split into a loop:
+            flux = None
+            for ie, e in enumerate(energy):
+                if ie % 100 == 0:
+                    print("Calculation at E={0}, K={1:.3f}".format(e, K))
+                I0 = self.intensities_on_mesh([e], theta, psi, harmonics)[0]
+                iflux = I0.sum(axis=(1, 2)) * dtheta * dpsi
+                if flux is None:
+                    flux = iflux
+                else:
+                    flux = np.vstack((flux, iflux))
             argm = np.argmax(flux, axis=0)
             fluxm = np.max(flux, axis=0)
             tunesE.append(energy[argm] / 1000.)
@@ -1495,8 +1542,8 @@ class Undulator(IntegratedSource):
         tmpKy = self.Ky
         powers = []
         for iK, K in enumerate(Ks):
-            if raycing._VERBOSITY_ > 10:
-                print("K={0}, {1} of {2}".format(K, iK+1, len(Ks)))
+            if raycing._VERBOSITY_ >= 10:
+                print("Calculation {1} of {2}, K={0}".format(K, iK+1, len(Ks)))
             self.Ky = K
             I0 = self.intensities_on_mesh(energy, theta, psi, harmonics)[0]
             if self.distE == 'BW':
@@ -1662,8 +1709,8 @@ class Undulator(IntegratedSource):
         betam = 1. - (1. + 0.5*self.Kx**2 + 0.5*self.Ky**2)*0.5*revgamma2
         wwuS = wS/wuS
 
-        Bsr = np.complex(0)
-        Bpr = np.complex(0)
+        Bsr = np.complex128(0)
+        Bpr = np.complex128(0)
 
         dirx = ddphiS
         diry = ddpsiS
@@ -1700,7 +1747,8 @@ class Undulator(IntegratedSource):
                     rloc = np.array([self.Ky*self.sintg[i]*revgamma,
                                      self.Kx*self.sintgph[i]*revgamma,
                                      betam*zloc-0.25*zterm*revgamma])
-                    dr = R0 - np.expand_dims(rloc, 1)
+
+                    dr = R0 - rloc
                     dist = np.linalg.norm(dr, axis=0)
 
                     drs = 0.5*(dr[0, :]**2+dr[1, :]**2) / dr[2, :]
@@ -1728,7 +1776,7 @@ class Undulator(IntegratedSource):
                          0.125*revgamma*(self.Ky**2 * sin2x[i] +
                                          self.Kx**2 * sin2xph[i]))
                     eucos = np.exp(1j*ucos)
-
+#                print("eucos.shape", eucos.shape)
                 betax = taperC*self.Ky*revgamma*self.costg[i]
                 betay = -self.Kx*revgamma*self.costgph[i]
                 betaz = 1. - 0.5*(revgamma2 + betax*betax + betay*betay)
@@ -1802,8 +1850,8 @@ class Undulator(IntegratedSource):
             R0v = None
 
         if NRAYS > 10:
-            if self.filamentBeam:
-                gamma = self.gamma
+            # if self.filamentBeam:
+            #     gamma = self.gamma * np.ones(NRAYS)
             Is_local, Ip_local = self._sp_sum(
                     ww1, w, wu, gamma, ddtheta, ddpsi, R0v)
         else:  # Convergence only

{xrt-1.5.0 → xrt-1.6.1}/xrt/backends/raycing/waves.py

@@ -263,12 +263,16 @@ For slits and screens, the two steps above are sufficient. For an optical
 element, another step is necessary.
 
 3. ``reflect`` method of the optical element is meant to take into account its
-   material properties. The intersection points are already known, as provided
-   by the previous ``prepare_wave``, which can be reported to ``reflect`` by
-   ``noIntersectionSearch=True``. Here, ``reflect`` takes the beam right before
-   the surface and propagates it to right after it. As a result of such a
-   zero-length travel, the wave gets no additional propagation phase but only a
-   complex-valued reflectivity coefficient and a new propagation direction.
+   material properties. The intersection points are already known (unless the
+   optical element is distorted, i.e. has methods `local_z_distorted` and
+   `local_n_distorted`), as provided by the previous ``prepare_wave``. This
+   fact (knowledge of the intersection points) can be reported to ``reflect``
+   by ``noIntersectionSearch=True``. Here, ``reflect`` takes the beam right
+   before the surface and propagates it to right after it. As a result of such
+   a zero-length travel, the wave gets no additional propagation phase but only
+   a complex-valued reflectivity coefficient and a new propagation direction.
+   Note that for parametric or distorted OEs this last-stroke travel is not
+   zero-length but the propagation phase is properly taken into account.
 
 These three methods are enough to describe wave propagation through the
 complete beamline. The first two methods, ``prepare_wave`` and ``diffract``,
@@ -309,8 +313,9 @@ this figure should be greater than ~10\ :sup:`4` for a good resulting quality.
 Coherence signatures
 ~~~~~~~~~~~~~~~~~~~~
 
-A standard way to define coherence properties is via *mutual intensity J* and
-*complex degree of coherence j* (DoC,  normalized *J*):
+A standard way to define coherence properties is via *mutual intensity J*
+(another common name is *cross-spectral density*) and *complex degree of
+coherence j* (DoC,  normalized *J*):
 
     .. math::
         J(x_1, y_1, x_2, y_2) \equiv J_{12} =
@@ -374,24 +379,21 @@ method above.
 3. It uses Principal Component Analysis (PCA) applied to the filament images
    :math:`E(x, y)`. It consists of the following steps.
 
-   a) Out of *r* repeats of :math:`E(x, y)` build a data matrix :math:`D` with
-      N\ :sub:`x`\ ×N\ :sub:`y` rows and *r* columns.
+   a) Out of *r* repeats of :math:`E(x, y)` build a stacked data matrix
+      :math:`D` with N\ :sub:`x`\ ×N\ :sub:`y` rows and *r* columns.
    b) The matrix :math:`J_{12}` is equal to the product :math:`DD^{+}`. Instead
       of solving this huge eigenvalue problem of (N\ :sub:`x`\ ×N\ :sub:`y`)²
-      size, we solve a typically smaller matrix :math:`D^{+}D` of the size
-      *r*\ ².
-   c) The biggest *r* eigenvalues of :math:`J_{12}` are equal to those of
-      :math:`D^{+}D` [proof to present in the coming paper]. To find the
-      primary (biggest) eigenvalue is the main objective of the modal analysis
-      (item 2 above); PCA can provide it much easier due to the smaller size of
-      the problem.
-   d) Also the *eigen modes* of :math:`J_{12}=DD^{+}` can be found by PCA via
-      the eigenvectors :math:`v`'s of :math:`D^{+}D`. The matrix
-      :math:`Dv_iv_i^{+}` is of the size of :math:`D` and has all the columns
-      proportional to each other [proof to present in the coming paper]. These
-      columns are the *i*\ th principal components for the corresponding
-      columns of :math:`D`. Being normalized, all the columns become equal and
-      give the *i*\ th eigenvector of :math:`J_{12}`.
+      size, we solve a typically smaller *covariance* matrix :math:`D^{+}D` of
+      the size *r*\ ².
+   c) The spectra of eigenvalues of matrices :math:`DD^{+}` and :math:`D^{+}D`
+      are equal, plus zeroes for the bigger matrix.
+   d) Their eigenvectors (being *eigenmodes* :math:`V_i` of :math:`DD^{+}` and
+      *principal component axes* :math:`v_i` of :math:`D^{+}D`) corresponding
+      to the same eigenvalue are transformed to each other with a factor
+      :math:`D` or :math:`D^{+}`: :math:`\tilde{V}_i = Dv_i` and
+      :math:`\tilde{v}_i = D^{+}V_i`, after which transformation they must be
+      additionally normalized (:math:`\tilde{v}_i` and :math:`\tilde{V}_i` are
+      non-normalized eigenvectors) [the proof is a one line matrix equation].
 
    Finally, PCA gives exactly the same information as the direct modal analysis
    (method No 2 above) but is cheaper to calculate by many orders of magnitude.
@@ -473,12 +475,18 @@ from .. import raycing
 from . import myopencl as mcl
 from . import sources as rs
 from .physconsts import CHBAR, CH
-try:
-    import pyopencl as cl  # analysis:ignore
-    os.environ['PYOPENCL_COMPILER_OUTPUT'] = '1'
+# try:
+#     import pyopencl as cl  # analysis:ignore
+#     os.environ['PYOPENCL_COMPILER_OUTPUT'] = '1'
+#     isOpenCL = True
+# except ImportError:
+#     isOpenCL = False
+
+if mcl.isOpenCL or mcl.isZMQ:
     isOpenCL = True
-except ImportError:
+else:
     isOpenCL = False
+
 _DEBUG = 20
 
 
@@ -489,6 +497,10 @@ if isOpenCL:
 else:
     waveCL = None
 
+GREEN = raycing.colorama.Fore.GREEN
+RED = raycing.colorama.Fore.RED
+RESET = raycing.colorama.Fore.RESET
+
 
 def prepare_wave(fromOE, wave, xglo, yglo, zglo):
     """Creates the beam arrays used in wave diffraction calculations. The
@@ -550,10 +562,10 @@ def prepare_wave(fromOE, wave, xglo, yglo, zglo):
     wave.c[:] = wave.zDiffr / wave.rDiffr
     wave.path[:] = 0.
     wave.fromOE = fromOE
-    wave.beamReflRays = np.long(0)
+    wave.beamReflRays = np.int64(0)
     wave.beamReflSumJ = 0.
     wave.beamReflSumJnl = 0.
-    wave.diffract_repeats = np.long(0)
+    wave.diffract_repeats = np.int64(0)
     return wave
 
 
@@ -590,8 +602,8 @@ def diffract(oeLocal, wave, targetOpenCL=raycing.targetOpenCL,
     good = oeLocal.state == 1
     goodlen = good.sum()
     if goodlen < 1e2:
-        print("Not enough good rays at {0}: {1} of {2}".format(
-              oe.name, goodlen, len(oeLocal.x)))
+        raycing.colorPrint("Not enough good rays at {0}: {1} of {2}".format(
+              oe.name, goodlen, len(oeLocal.x)), "RED")
         return
 #        goodIn = beam.state == 1
 #        self.beamInRays += goodIn.sum()
@@ -599,8 +611,12 @@ def diffract(oeLocal, wave, targetOpenCL=raycing.targetOpenCL,
 
     # this would be better in prepare_wave but energy is unknown there yet
     nf, spz = qualify_sampling(wave, oeLocal.E[0], goodlen)
-    print("Effective Fresnel number = {0:.3g}, samples per zone = {1:.3g}".
-          format(nf, spz))
+    toOEname = ' to ' + wave.toOE.name if hasattr(wave, 'toOE') else ''
+    print("Diffraction from {0}{1}:\n"
+          "Effective Fresnel number = {2:.3g}, {3:.3g} samples, "
+          "{5}{4:.3g} samples per zone{6}"
+          .format(oe.name, toOEname, nf, goodlen, spz,
+                  GREEN if spz > 1e4 else RED, RESET))
 
     shouldCalculateArea = False
     if not hasattr(oeLocal, 'area'):
@@ -617,7 +633,7 @@ def diffract(oeLocal, wave, targetOpenCL=raycing.targetOpenCL,
             secondDim = oeLocal.y
         elif hasattr(oe, 'propagate'):  # aperture
             secondDim = oeLocal.z
-        elif hasattr(oe, 'build_I_map'):  # source
+        elif hasattr(oe, 'shine'):  # source
             secondDim = oeLocal.z
         else:
             raise ValueError('Unknown diffracting element!')
@@ -632,7 +648,7 @@ def diffract(oeLocal, wave, targetOpenCL=raycing.targetOpenCL,
         if hasattr(oeLocal, 'areaFraction'):
             oeLocal.area *= oeLocal.areaFraction
     if _DEBUG > 10:
-        print("The area of {0} under the beam is {1:.4g}".format(
+        print("The area of {0} under the beam is {1:.4g} mm²".format(
               oe.name, oeLocal.area))
 
     if hasattr(oe, 'rotationSequence'):  # OE
@@ -773,6 +789,7 @@ def diffract(oeLocal, wave, targetOpenCL=raycing.targetOpenCL,
         print("diffract on {0} completed in {1:.4f} s".format(
               oe.name, time.time()-t0))
 
+    glo.createdByDiffract = True
     return glo