def meanSterr(self, remove=False, max=None): """ Returns array of mean and standard error of measured data. Parameters ---------- remove : bool Remove inf and -inf as well as nan. (default: False) NOTE: A warning will be issued if remove == False and such objects are encountered. max : float or None Remove data which is strictly above max in absolute value. (default: None) NOTE: max != None will trigger remove = True. Returns ------- SCGF : (self.sValues.size, 3) float Numpy array Scaled cumulant generating function. orderParameter : (self.sValues.size, 3) float Numpy array. Order parameter. orderParameterSq : (self.sValues.size, 3) float Numpy array. Squared order parameter. NOTE: (0) Biasing parameter. (1) Mean. (2) Standard error. I : (self.sValues.size, 4) float Numpy array Rate function. NOTE: (0) (Squared) order parameter. (1) Standard error on (squared) order parameter. (2) Rate function. (3) Standard error on rate function. """ SCGF = np.empty((self.sValues.size, 3)) orderParameter = np.empty((self.sValues.size, 3)) orderParameterSq = np.empty((self.sValues.size, 3)) I = np.empty((self.sValues.size, 4)) for i in range(self.sValues.size): SCGF[i] = [ self.sValues[i], *mean_sterr(self.SCGF[i], remove=remove, max=max) ] orderParameter[i] = [ self.sValues[i], *mean_sterr(self.orderParameter[i], remove=remove, max=max) ] orderParameterSq[i] = [ self.sValues[i], *mean_sterr(self.orderParameterSq[i], remove=remove, max=max) ] I[i] = [ *mean_sterr(self.I[i, :, 0], remove=remove, max=max), *mean_sterr(self.I[i, :, 1], remove=remove, max=max) ] return SCGF, orderParameter, orderParameterSq, I
def msd(self, n_max=100, int_max=100, min=None, max=None, jump=1): """ Compute mean square displacement. Parameters ---------- n_max : int Maximum number of times at which to compute the mean square displacement. (default: 100) int_max : int Maximum number of different intervals to consider when averaging the mean square displacement. (default: 100) min : int or None Minimum time at which to compute the displacement. (default: None) NOTE: if min == None, then min = 1. max : int or None Maximum time at which to compute the displacement. (default: None) NOTE: if max == None, then max is taken to be the maximum according to the choice of int_max. jump : int Compute displacements by treating frames in packs of `jump'. This can speed up calculation but also give unaccuracies if `jump'*self.dt is of the order of the system size. (default: 1) Returns ------- msd_sterr : (3, *) float numpy array Array of: (0) lag time at which the mean square displacement is computed, (1) mean square displacement, (2) standard error of the computed mean square displacement. """ min = 1 if min == None else int(min) max = ((self.frames - self.skip - 1) // int_max if max == None else int(max)) # COMPUTE RELEVANT DISPLACEMENTS FROM DATA dt = logspace(min, max, n_max) # array of lag times displacements = self.dtDisplacements( dt, # array of displacements for different initial times and lag times int_max=int_max, jump=jump, norm=False) # COMPUTE MEAN SQUARE DISPLACEMENTS msd_sterr = [] for i in range(dt.size): disp = displacements[:, i] if self.N > 1: disp -= disp.mean(axis=1).reshape( displacements.shape[0], 1, 2 ) # substract mean displacement of particles during each considered intervals disp.reshape(displacements.shape[0] * self.N, 2) msd_sterr += [[ dt[i], *mean_sterr(np.sum(disp**2, axis=-1).flatten()) ]] return np.array(msd_sterr)
def corWorkOrderAve(self, n_max=100, int_max=None, min=None, max=None, log=False): """ Compute correlations of the fluctuations of the work averaged over an interval of length `tau' and the fluctuations of the order parameter norm at the beginning of the interval. Parameters ---------- n_max : int Maximum number of values at which to evaluate the correlation. (default: 100) int_max : int or None Maximum number of different intervals to consider in order to compute the mean which appears in the correlation expression. (default: None) NOTE: if int_max == None, then a maximum number of disjoint intervals will be considered. min : int or None Minimum value at which to compute the correlation. (default: None) NOTE: this value is passed as `min' to self.n. max : int or None Maximum value at which to compute the correlation. (default: None) NOTE: this value is passed as `max' to self.n. log : bool Logarithmically space values at which the correlations are computed. (default: True) Returns ------- cor : (5, *) numpy array Array of: (0) value at which the correlation is computed, (1) mean of the computed correlation, (2) standard error of the computed correlation, (3) standard deviation of the active work, (4) standard deviation of the order parameter norm. """ cor = [] for n in self._n(n_max=n_max, min=min, max=max, log=log): works = (lambda l: l - np.mean(l))( self.nWork(n, int_max=int_max) ) # fluctuations of the active wok on intervals of size n orders = (lambda l: l - np.mean(l))( np.array( list( map( # fluctuations of the order parameter norm at the beginning of these intervals lambda t: self.getOrderParameter(t, norm=True), self.framesWork * self._time0(n, int_max=int_max))))) workOrder = works * orders cor += [[n, *mean_sterr(workOrder), np.std(works), np.std(orders)]] return np.array(cor)
def corForceForce(self, n_max=100, int_max=None, min=1, max=None, log=False): """ Returns fluctuations of the force autocorrelations. Parameters ---------- n_max : int Maximum number of values at which to evaluate the correlation. (default: 100) int_max : int or None Maximum number of different intervals to consider in order to compute the mean which appears in the correlation expression. (default: None) NOTE: if int_max == None, then a maximum number of disjoint intervals will be considered. min : int or None Minimum value at which to compute the correlation. (default: 1) max : int or None Maximum value at which to compute the correlation. (default: None) NOTE: if max == None, then n_max = self.frames - self.skip - 1. log : bool Logarithmically space values at which the correlations are computed. (default: False) Returns ------- cor : (3, *) numpy array Array of: (0) value at which the correlation is computed, (1) mean of the computed correlation, (2) standard error of the computed correlation, (3) mean of the squared norm of the flucuations of the force. """ min = 1 if min == None else int(min) max = self.frames - self.skip - 1 if max == None else int(max) int_max = ((self.frames - self.skip - 1)//max if int_max == None else int(int_max)) if log: space = logspace else: space = linspace dt = space(min, max, n_max) time0 = linspace(self.skip, self.frames - max - 1, int_max) cor = [] forcesIni = ( (lambda l: (np.array(l) - np.mean(l, axis=1).reshape(time0.size, 1)).flatten())( # fluctuations of the force scalar the orientation at t0 list(map( lambda t: self._ForceOrientation(t), time0)))) for tau in dt: forcesFin = ( (lambda l: np.array(l) - np.mean(l, axis=1).reshape(time0.size, 1, 2))( # fluctuations of the force at t0 + tau list(map(lambda t: self.getForce(t + tau), time0)))).reshape( (self.N*time0.size, 2)) forcesForces = list(map(lambda x, y: np.dot(x, y), *(forcesIni, forcesFin))) forcesNormSq = (list(map(lambda x, y: np.dot(x, y), *(forcesIni, forcesIni))) + list(map(lambda x, y: np.dot(x, y), *(forcesFin, forcesFin)))) cor += [[tau, *mean_sterr(forcesForces), np.mean(forcesNormSq)]] return np.array(cor)
def corForceVelocity(self, n_max=100, int_max=None, min=1, max=None, log=False): """ Returns correlations of the scalar product of force and velocity. Parameters ---------- n_max : int Maximum number of values at which to evaluate the correlation. (default: 100) int_max : int or None Maximum number of different intervals to consider in order to compute the mean which appears in the correlation expression. (default: None) NOTE: if int_max == None, then a maximum number of disjoint intervals will be considered. min : int or None Minimum value at which to compute the correlation. (default: 1) max : int or None Maximum value at which to compute the correlation. (default: None) NOTE: if max == None, then n_max = self.frames - self.skip - 1. log : bool Logarithmically space values at which the correlations are computed. (default: False) Returns ------- cor : (3, *) numpy array Array of: (0) value at which the correlation is computed, (1) mean of the computed correlation, (2) standard error of the computed correlation, (3) product of the standard deviations of the scalar product at initial and final times. """ min = 1 if min == None else int(min) max = self.frames - self.skip - 1 if max == None else int(max) int_max = ((self.frames - self.skip - 1)//max if int_max == None else int(int_max)) if log: space = logspace else: space = linspace dt = space(min, max, n_max) time0 = linspace(self.skip, self.frames - max - 1, int_max) cor = [] forcesVelocitesIni = ( (lambda l: np.array(l) - np.mean(l, axis=1).reshape(time0.size, 1))( # fluctuations of the scalar product of force and velocity at t0 list(map( lambda t: list(map( lambda f, v: np.dot(f, v), *(self.getForce(t), self.getVelocities(t, norm=False)))), time0)))).flatten() print(forcesVelocitesIni) for tau in dt: forcesVelocitesFin = ( (lambda l: np.array(l) - np.mean(l, axis=1).reshape(time0.size, 1))( # fluctuations of the scalar product of force and velocity at t0 + tau list(map( lambda t: list(map( lambda f, v: np.dot(f, v), *(self.getForce(t), self.getVelocities(t, norm=False)))), time0 + tau)))).flatten() print(forcesVelocitesFin) cor += [[ tau, *mean_sterr(forcesVelocitesIni*forcesVelocitesFin), forcesVelocitesIni.std()*forcesVelocitesFin.std()]] return np.array(cor)
def meanSterr(self, remove=False, max=None): """ Returns array of mean and standard error of measured data. Parameters ---------- remove : bool Remove inf and -inf as well as nan. (default: False) NOTE: A warning will be issued if remove == False and such objects are encountered. max : float or None Remove data which is strictly above max in absolute value. (default: None) NOTE: max != None will trigger remove = True. Returns ------- activeWork : (self.gValues.size, 3) float Numpy array Normalised rate of active work. activeWorkForce : (self.gValues.size, 3) float Numpy array Force part of the normalised rate of active work. activeWorkOri : (self.gValues.size, 3) float Numpy array Orientation part of the normalised rate of active work. orderParameter : (self.gValues.size, 3) float Numpy array Order parameter. torqueIntegral1 : (self.gValues.size, 3) float Numpy array First torque integral. torqueIntegral2 : (self.gValues.size, 3) float Numpy array Second torque integral. NOTE: (0) Torque parameter. (1) Mean. (2) Standard error. Lambda : (self.gValues.size, 4) float Numpy array Bound to the rate function. NOTE: (0) Active work. (1) Standard error on active work. (2) Bound to the rate function. (3) Standard error on the boudn to the function. """ activeWork = np.empty((self.gValues.size, 3)) activeWorkForce = np.empty((self.gValues.size, 3)) activeWorkOri = np.empty((self.gValues.size, 3)) orderParameter = np.empty((self.gValues.size, 3)) torqueIntegral1 = np.empty((self.gValues.size, 3)) torqueIntegral2 = np.empty((self.gValues.size, 3)) Lambda = np.empty((self.gValues.size, 4)) for i in range(self.gValues.size): activeWork[i] = [ self.gValues[i], *mean_sterr(self.activeWork[i], remove=remove, max=max)] activeWorkForce[i] = [ self.gValues[i], *mean_sterr(self.activeWorkForce[i], remove=remove, max=max)] activeWorkOri[i] = [ self.gValues[i], *mean_sterr(self.activeWorkOri[i], remove=remove, max=max)] orderParameter[i] = [ self.gValues[i], *mean_sterr(self.orderParameter[i], remove=remove, max=max)] torqueIntegral1[i] = [ self.gValues[i], *mean_sterr(self.torqueIntegral1[i], remove=remove, max=max)] torqueIntegral2[i] = [ self.gValues[i], *mean_sterr(self.torqueIntegral2[i], remove=remove, max=max)] Lambda[i] = [ *mean_sterr(self.Lambda[i, :, 0], remove=remove, max=max), *mean_sterr(self.Lambda[i, :, 1], remove=remove, max=max)] return (activeWork, activeWorkForce, activeWorkOri, orderParameter, torqueIntegral1, torqueIntegral2, Lambda)
def meanSterr(self, remove=False, max=None): """ Returns array of mean and standard error of measured data. Parameters ---------- remove : bool Remove inf and -inf as well as nan. (default: False) NOTE: A warning will be issued if remove == False and such objects are encountered. max : float or None Remove data which is strictly above max in absolute value. (default: None) NOTE: max != None will trigger remove = True. Returns ------- SCGF : (self.sValues.size, 3) float Numpy array Scaled cumulant generating function. activeWork : (self.sValues.size, 3) float Numpy array Normalised rate of active work. activeWorkForce : (self.sValues.size, 3) float Numpy array Force part of the normalised rate of active work. activeWorkOri : (self.sValues.size, 3) float Numpy array Orientation part of the normalised rate of active work. orderParameter : (self.sValues.size, 3) float Numpy array Order parameter. NOTE: (0) Biasing parameter. (1) Mean. (2) Standard error. I : (self.sValues.size, 4) float Numpy array Rate function. NOTE: (0) Active work. (1) Standard error on active work. (2) Rate function. (3) Standard error on rate function. """ if max != None: remove = True SCGF = np.empty((self.sValues.size, 3)) activeWork = np.empty((self.sValues.size, 3)) activeWorkForce = np.empty((self.sValues.size, 3)) activeWorkOri = np.empty((self.sValues.size, 3)) orderParameter = np.empty((self.sValues.size, 3)) I = np.empty((self.sValues.size, 4)) for i in range(self.sValues.size): SCGF[i] = [ self.sValues[i], *mean_sterr(self.SCGF[i], remove=remove, max=max) ] activeWork[i] = [ self.sValues[i], *mean_sterr(self.activeWork[i], remove=remove, max=max) ] activeWorkForce[i] = [ self.sValues[i], *mean_sterr(self.activeWorkForce[i], remove=remove, max=max) ] activeWorkOri[i] = [ self.sValues[i], *mean_sterr(self.activeWorkOri[i], remove=remove, max=max) ] orderParameter[i] = [ self.sValues[i], *mean_sterr(self.orderParameter[i], remove=remove, max=max) ] I[i] = [ *mean_sterr(self.I[i, :, 0], remove=remove, max=max), *mean_sterr(self.I[i, :, 1], remove=remove, max=max) ] return (SCGF, activeWork, activeWorkForce, activeWorkOri, orderParameter, I)
def corOrderOrder(self, n_max=100, int_max=100, max=None, norm=False, log=False): """ Compute autocorrelations of the fluctuations of the order parameter. Parameters ---------- n_max : int Maximum number of values at which to evaluate the correlation. (default: 100) int_max : int Maximum number of different intervals to consider in order to compute the mean which appears in the correlation expression. (default: 100) max : int or None Maximum value at which to compute the correlation. (default: None) NOTE: if max == None, then max = self.frames - 1. norm : bool Consider the norm of the order parameter rather than its vector form. (default: False) log : bool Logarithmically space values at which the correlations are computed. (default: True) Returns ------- cor : (3, *) numpy array Array of: (0) value at which the correlation is computed, (1) mean of the computed correlation, (2) standard error of the computed correlation. """ if max == None: max = self.frames - 1 if log: space = logspace else: space = linspace cor = [] for tau in space(1, max, n_max): time0 = list( OrderedDict.fromkeys( np.linspace(self.skip * self.framesWork, self.frames - tau - 1, int_max, endpoint=True, dtype=int))) ordersIni = (lambda l: np.array(l) - np.mean(l, axis=0))(list( map(lambda t: self.getOrderParameter(t, norm=norm), time0))) ordersFin = (lambda l: np.array(l) - np.mean(l, axis=0))(list( map(lambda t: self.getOrderParameter(t + tau, norm=norm), time0))) orderOrder = list( map(lambda x, y: np.dot(x, y), *(ordersIni, ordersFin))) cor += [[tau, *mean_sterr(orderOrder)]] return np.array(cor)
def corWorkOrderIns(self, tau0=1, n_max=100, int_max=None, min=None, max=None, log=False): """ Compute correlations of the fluctuations of the order parameter norm at a given time and the fluctuations of the active work averaged over a time `tau0' at a later time. Parameters ---------- tau0 : int Number of consecutive individual active works on which to average it. (default: 1) n_max : int Maximum number of values at which to evaluate the correlation. (default: 100) int_max : int or None Maximum number of different intervals to consider in order to compute the mean which appears in the correlation expression. (default: None) NOTE: if int_max == None, then a maximum number of disjoint intervals will be considered. min : int or None Minimum value at which to compute the correlation. (default: None) NOTE: if min == None then min = `tau0', otherwise the minimum of `tau0' and `min' is taken. max : int or None Maximum value at which to compute the correlation. (default: None) NOTE: this value is passed as `max' to self.n. log : bool Logarithmically space values at which the correlations are computed. (default: True) Returns ------- cor : (5, *) numpy array Array of: (0) value at which the correlation is computed, (1) mean of the computed correlation, (2) standard error of the computed correlation, (3) standard deviation of the active work, (4) standard deviation of the order parameter norm. """ cor = [] for n in self._n( n_max=n_max, log=log, min=(2 * tau0 if min == None else np.max([tau0 + min, 2 * tau0])), max=(None if max == None else tau0 + max)): ordersIni = (lambda l: l - np.mean(l))( list( map( lambda t: self.getOrderParameter( t, norm=True ), # fluctuations of the active work averaged between t0 and t0 + tau0 self._time0(n, int_max=int_max)))) worksFin = (lambda l: l - np.mean(l))( list( map( lambda t: self.workArray[t + n - tau0:t + n].mean( ), # fluctuations of the active work averaged between t0 and t0 + tau0 self._time0(n, int_max=int_max)))) workOrder = ordersIni * worksFin cor += [[ n - tau0, *mean_sterr(workOrder), np.std(ordersIni), np.std(worksFin) ]] return np.array(cor)
def varWorkFromCorWork(self, tau0=1, n=100, int_max=None, bruteForce=True): """ Compute variance of the active work from its "instantaneous" fluctuations correlations. This function is primarily for consistency testing of the correlations functions. Parameters ---------- tau0 : int Number of consecutive individual active works on which to average it, and for which correlations will be computed. (default: 1) n : int Compute variance for tau = i*tau0 with i in {1, ..., n}. (default: 100) int_max : int or None Maximum number of different intervals to consider in order to compute the mean which appears in the correlation expression. (default: None) NOTE: if int_max == None, then a maximum number of intervals will intervals will be considered (joint if bruteForce else disjoint). bruteForce : bool Use self.corWorkWorkInsBruteForce rather than self.corWorkWorkIns. (default: True) Returns ------- var : (3, *) numpy array Array of: (0) value at which the variance is computed, (1) mean of the computed variance, (2) standard error of the computed variance. """ if bruteForce: corWorkWorkIns = self.corWorkWorkInsBruteForce else: corWorkWorkIns = self.corWorkWorkIns if bruteForce: cor = self.corWorkWorkInsBruteForce(tau0, n_max=n, int_max=int_max, max=n - 1, log=False) else: cor = self.corWorkWorkIns(tau0, n_max=n, int_max=int_max, min=tau0, max=(n - 1) * tau0, log=False) var0 = mean_sterr( (lambda l: (l - l.mean())**2)(self.nWork(tau0, int_max=int_max))) var = [] for n0 in range(1, n + 1): var += [[n0 * tau0, var0[0] / n0, (var0[1] / n0)**2]] for i in range(1, n0): var[-1][1] += 2 * (n0 - i) * cor[i - 1, 1] / (n0**2) var[-1][2] += (2 * (n0 - i) * cor[i - 1, 2] / (n0**2))**2 var[-1][2] = np.sqrt(var[-1][2]) return np.array(var)
def corWorkWorkInsBruteForce(self, workPart1=None, workPart2=None, tau0=1, n_max=100, int_max=None, max=None, log=True): """ Compute (cross) correlations of the fluctuations of the work averaged over `tau0' between different times. This algorithm computes the correlations more quickly by averaging over successive couples of initial and final values of the active work. Results of this function should then be taken with care as some other unwanted low-time correlations could be picked. Parameters ---------- workPart1 : string Part of the active work to consider at the beginning of the interval: * 'all': active work, * 'force': force part of the active work, * 'orientation': orientation part of the active work, * 'noise': noise part of the active work. (default: None) NOTE: if workPart1 == None, then self.workArray is taken. workPart2 : string Part of the active work to consider at the end of the interval. (default: None) NOTE: if workPart2 == None, then self.workArray is taken. tau0 : int Number of consecutive individual active works on which to average it. (default: 1) n_max : int Maximum number of values at which to evaluate the correlation. (default: 100) int_max : int or None Maximum number of different intervals to consider in order to compute the mean which appears in the correlation expression. (default: None) NOTE: if int_max == None, then a maximum number of intervals will intervals will be considered. max : int or None Maximum value at which to compute the correlation in units of tau0. (default: None) NOTE: if max == None, the maximum number of values is computed. log : bool Logarithmically space values at which the correlations are computed. (default: True) Returns ------- cor : (3, *) numpy array Array of: (0) value at which the correlation is computed, (1) mean of the computed correlation, (2) standard error of the computed correlation. """ work1 = (self.workArray if workPart1 == None else self.workDict[workPart1]) work2 = (self.workArray if workPart2 == None else self.workDict[workPart2]) if log: space = logspace else: space = linspace if int_max == None: int_max = (self.numberWork - self.skip) // tau0 Nsample = int( np.min([(self.numberWork - self.skip) // tau0, int_max * tau0]) ) # size of the sample of consecutive normalised rates of active work to consider workArray1 = np.array( list( map( # array of consecutive normalised rate of active work averaged of time tau0 lambda t: work1[self.skip + t * tau0:self.skip + t * tau0 + tau0].mean(), range(Nsample)))) workArray1 -= workArray1.mean( ) # only considering fluctuations to the mean if workPart1 == workPart2: workArray2 = workArray1 else: workArray2 = np.array( list( map( # array of consecutive normalised rate of active work averaged of time tau0 lambda t: work2[self.skip + t * tau0:self.skip + t * tau0 + tau0].mean(), range(Nsample)))) workArray2 -= workArray2.mean( ) # only considering fluctuations to the mean lagTimes = space( # array of lag times considered 1, (Nsample - 1) if max == None else int(np.min([max, Nsample - 1])), n_max) cor = list( map( lambda dt: [ tau0 * dt, *mean_sterr( (workArray1 * np.roll(workArray2, -dt))[:Nsample - dt]) ], lagTimes)) return np.array(cor)
def corWorkWorkIns(self, workPart1=None, workPart2=None, tau0=1, n_max=100, int_max=None, min=None, max=None, log=True): """ Compute (cross) correlations of the fluctuations of the work averaged over `tau0' between different times. Parameters ---------- workPart1 : string Part of the active work to consider at the beginning of the interval: * 'all': active work, * 'force': force part of the active work, * 'orientation': orientation part of the active work, * 'noise': noise part of the active work. (default: None) NOTE: if workPart1 == None, then self.workArray is taken. workPart2 : string Part of the active work to consider at the end of the interval. (default: None) NOTE: if workPart2 == None, then self.workArray is taken. tau0 : int Number of consecutive individual active works on which to average it. (default: 1) n_max : int Maximum number of values at which to evaluate the correlation. (default: 100) int_max : int or None Maximum number of different intervals to consider in order to compute the mean which appears in the correlation expression. (default: None) NOTE: if int_max == None, then a maximum number of disjoint intervals will be considered. min : int or None Minimum value at which to compute the correlation. (default: None) NOTE: if min == None then min = `tau0', otherwise the minimum of `tau0' and `min' is taken. max : int or None Maximum value at which to compute the correlation. (default: None) NOTE: this value is passed as `max' to self.n. log : bool Logarithmically space values at which the correlations are computed. (default: True) Returns ------- cor : (5, *) numpy array Array of: (0) value at which the correlation is computed, (1) mean of the computed correlation, (2) standard error of the computed correlation, (3) standard deviation of the active work computed at the beginning of the interval, (4) standard deviation of the active work computed at the end of the interval. """ work1 = (self.workArray if workPart1 == None else self.workDict[workPart1]) work2 = (self.workArray if workPart2 == None else self.workDict[workPart2]) cor = [] for n in self._n( n_max=n_max, log=log, min=(2 * tau0 if min == None else np.max([tau0 + min, 2 * tau0])), max=(None if max == None else tau0 + max)): worksIni = (lambda l: l - np.mean(l))( list( map( lambda t: work1[t:t + tau0].mean( ), # fluctuations of the active work averaged between t0 and t0 + tau0 self._time0(n, int_max=int_max)))) worksFin = (lambda l: l - np.mean(l))( list( map( lambda t: work2[t + n - tau0:t + n].mean( ), # fluctuations of the active work averaged between t0 and t0 + tau0 self._time0(n, int_max=int_max)))) workWork = worksIni * worksFin cor += [[ n - tau0, *mean_sterr(workWork), np.std(worksIni), np.std(worksFin) ]] return np.array(cor)
def corWorkWorkAve(self, tau0=1, n_max=100, int_max=None, min=None, max=None, log=True): """ Compute correlations of the fluctuations of the work averaged over `tau0' at the beginning of an interval and the fluctuations of the work averaged over the whole interval. Parameters ---------- tau0 : int Number of consecutive individual active works on which to average it. (default: 1) n_max : int Maximum number of values at which to evaluate the correlation. (default: 100) int_max : int or None Maximum number of different intervals to consider in order to compute the mean which appears in the correlation expression. (default: None) NOTE: if int_max == None, then a maximum number of disjoint intervals will be considered. min : int or None Minimum value at which to compute the correlation. (default: None) NOTE: if min == None then this value is passed as `min' to self.n, otherwise the minimum of `tau0' and `min' is taken. max : int or None Maximum value at which to compute the correlation. (default: None) NOTE: this value is passed as `max' to self.n. log : bool Logarithmically space values at which the correlations are computed. (default: True) Returns ------- cor : (5, *) numpy array Array of: (0) value at which the correlation is computed, (1) mean of the computed correlation, (2) standard error of the computed correlation, (3) standard deviation of the active work computed at the beginning of the interval, (4) standard deviation of the active work computed over the interval. """ cor = [] for n in self._n(n_max=n_max, max=max, log=log, min=(None if min == None else np.max([min, tau0]))): worksTot = (lambda l: l - np.mean(l))( self.nWork(n, int_max=int_max) ) # fluctuations of the active wok on intervals of size n worksIni = (lambda l: l - np.mean(l))( list( map( lambda t: self.workArray[t:t + tau0].mean( ), # fluctuations of the active work averaged on tau0 at the beginning of these intervals self._time0(n, int_max=int_max)))) workWork = worksTot * worksIni cor += [[ n, *mean_sterr(workWork), np.std(worksTot), np.std(worksIni) ]] return np.array(cor)