---
abstract: 'Creep mechanisms in uniaxially compressed 3D granular solids comprised of faceted frictionless grains are studied numerically using a constant pressure and constant stress simulation method. Rapid uniaxial compression followed by slow dilation is predicted on the basis of a logarithmic creep phenomenon. Micromechanical analysis indicates the existence of a correlation between granular creep and grain-scale deformations. Localized regions of large strain appear during creep and grow in magnitude and size with time. Furthermore, the accumulation of non-affine granular displacements increases linearly with local strain, thereby providing insights into the origins of plastic dissipation during stress-driven creep evolution. The prediction of slow logarithmic dynamics in the absence of friction indicates a universality in the role of plastic dissipation during the creep of granular solids.'
author:
- Ishan Srivastava
- 'Timothy S. Fisher'
bibliography:
- 'main.bib'
title: Local Plasticity as the Source of Creep and Slow Dynamics in Granular Materials
---

Long-time evolution of granular materials under external stress is of significant importance in many natural and artificial processes. Time-dependent aging and creep in soils [@Schmertmann1991] and concrete [@Vandamme2009] under uniaxial stress are critically associated with the structural stability of man-made and natural geological constructs. The arrest (*jamming*) of dry cohesionless granular materials upon densification [@OHern2003; @Majmudar2007] and/or the application of external stress [@Bi2011; @Dagois-Bohy2012] has been numerically and experimentally investigated. Concomitantly, external stress can also initiate the yielding (*unjamming*) of granular packings [@DaCruz2005]. Critical state theories in soil mechanics [@Nedderman:1992aa] have proposed rate-independent, Mohr-Coulomb-type friction laws to describe the yielding of granular solids, and more recently, rate-dependent constitutive laws [@Jop2006] have improvised a description of dense granular flows above yield stress. However, a detailed description of the internal dynamics in granular materials below the yield stress is lacking [@Balmforth2014].

Diverse experiments at various length scales—from colloidal [@Coussot2002] to bio-cellular [@Bursac2005] to geological [@Houssais2015]—on kinematically constrained, glassy materials have demonstrated aging and creep relaxation at stresses below their yield strength. Experiments on granular samples have demonstrated slow aging with time and creep when subjected to a constant external stress [@Nguyen2011; @Amon2012] or a quasistatically increasing stress in stick-slip shearing experiments [@Hartley2003; @Nasuno1998]. Logarithmically slow densification has also been observed in various experiments on compaction in confined granular systems [@Brujic2005; @Richard2005; @Knight1995].

Several explanations and models have been proposed for mechanically induced aging behavior in granular systems. Hartley and Behringer [@Hartley2003] suggested that collective irreversible granular rearrangements are responsible for slow dynamics. The emergence of such collective irreversibility in amorphous materials is often explained through long-ranged elastic coupling of localized plastic events [@Maloney2006; @Schall2007]. Macroscopically, this complex spatio-temporal phenomenon is often condensed into a dynamical internal state variable called fluidity [@Kamrin2012], based on the theoretical formulations of soft glassy rheology [@Bocquet2009]. On the other hand, other explanations attribute slowly evolving dynamics to the gradual strengthening (or aging) of the individual solid-friction contacts with a slow increase in the local coefficient of friction [@Kuhn1993].

In this letter, we simulate the temporal evolution of the micromechanics of granular packings comprised of faceted grains that are confined at a constant pressure and subjected to a constant uniaxial compressive stress below the yield limit. The simulations reveal logarithmically slow creep after initial exponentially rapid dynamics. The influence of structural transformations on creep rheology is assessed by decomposing the local grain-scale motions into elastic and plastic contributions. Initial exponential dynamics are governed by elastic deformations, and plastic transformations dominate granular motion as the system transitions into a slow creep. The accumulated local plasticity in stressed granular packings—characterized by non-affine granular motions—is observed to be strongly correlated with a slow creep at the macroscale. We hypothesize that the concert of collective granular dynamics arising from a complex interplay of local elastic and plastic deformations is the source of slow creep dynamics and it is a hallmark of the general class of amorphous solids.

#### Simulation Details.

Initially, elastic and frictionless grains were jammed under a hydrostatic pressure $P$ through a recently introduced enthalpy-based, variable-cell jamming simulation method [@Smith2014]. The system is three-dimensional and contains $4096$ monodisperse, octahedral-shaped grains, as shown in the inset of Fig. \[global\](a). A very small ratio of the hydrostatic pressure and the material elastic modulus of the grains is prescribed here to represent the limit of hard granular systems [@DaCruz2005]. Repulsive pair potentials describe the elastic force $\mathbf{F}^{\text{e}}$ and moment $\mathbf{M}^{\text{e}}$ between contacting grains (for details on force and moment calculations, see [@Smith2010]).

To investigate the creep phenomenon in jammed granular systems under a constant external uniaxial stress $\bm{\sigma}_{\text{ext}}$, we introduce dynamics into the motion of grains and the periodic cell. The magnitude of the [*[xx]{}*]{} component of the stress tensor is $\sigma_{\text{ext}}$ and the other components are zero. The geometry of the periodic cell is described by a metric tensor $\bm{g}=\bm{h}^{T}\bm{h}$, where $\bm{h}$ is a matrix whose columns are the Bravais lattice vectors of the periodic cell. Translational motion of a grain $i$ is described in lattice coordinates $\bm{s}_{i}=\bm{h}^{-1}\bm{r}_{i}$ instead of Cartesian coordinates $\bm{r}_{i}$, and the rotation $\bm{\omega}_{i}$ is described relative to its center of mass. Dissipation during granular motion is modeled using a mean-field dissipation model [@Vagberg2014] described in detail in the accompanying supplementary material [^1].

Under low external stresses, the creep progresses at low strain rates, and the inertial effects of granular and periodic cell motion are assumed to be negligible in comparison to elastic interactions and dissipation. The equations of motion of grain displacement, grain rotation and periodic cell deformation are derived from a Lagrangian formulation [@Note1]. The equations of non-affine displacement and rotation of a grain $i$ are given as: $$D_{g}\dot{\bm{s}}_{i} = \widetilde{\mathbf{F}}_{i}^{e} \qquad\text{and}\qquad D_{g}\dot{\bm{\omega}}_{i} = \mathbf{M}_{i}^{e},
\label{eq1}$$

where $\widetilde{\mathbf{F}}_{i}^{\text{e}}$ is the elastic force in lattice coordinates [@Souza1997], $\mathbf{M}_{i}^{\text{e}}$ is the net moment on grain $i$ due to all the contacting grains, and $D_{g}$ is the dissipation constant for granular motion. The equation of motion of the periodic cell in the limit of negligible inertia is defined as: $$D_{c}\dot{\bm{g}} + \left(\widetilde{\bm{\sigma}}_{\text{app}} - \widetilde{\bm{\sigma}}_{\text{int}}\right) = 0.
\label{eq2}$$ Here, $\widetilde{\bm{\sigma}}_{\text{int}}$ is the internal stress tensor [@Smith2014] in lattice coordinates and $\bm{\sigma}_{\text{app}}=\bm{\sigma}_{\text{ext}} + P\mathbf{I}$ is the total applied stress, where $\mathbf{I}$ is the identity matrix. The applied stress tensor in lattice coordinates is denoted by $\widetilde{\bm{\sigma}}_{\text{app}}$ [@Note1]. The dissipation constant for periodic cell motion is denoted by $D_{c}$.

The equations of motion, Eqs. (\[eq1\]) and (\[eq2\]), were integrated using the Heuns second order predictor-corrector method. The units of time were chosen such that all dissipation constants are unity. All displacements and volumes are scaled by grain size and volume respectively, and the stresses are scaled by the material elastic modulus of the grains.

![\[global\] (a) Evolution of deviatoric strain $\gamma(t)$ for four different uniaxial compressive stresses. The solid black curves represent fits to Eq. (\[eq3\]) \[inset: a selected realization of jammed octahedral grains. Dark lines indicate periodic-cell boundaries\]. (b) Volumetric strain evolution $\epsilon_{v}(t)$ for four different uniaxial compressive stresses $\sigma_{\text{ext}}$ (see legend in (b) for color codes; arrow represents increasing stress) \[inset: evolution of compressive strain $\epsilon_{xx}$ along the axial direction and tensile strain $\left(\epsilon_{yy}+\epsilon_{zz}\right)$ along the transverse direction of the periodic cell boundaries relative to the direction of applied external stress\].](Fig1)

#### Macroscopic Evolution.

Uniaxial compressive stress was applied to the granular packing of $4096$ octahedral grains jammed at pressure $P=10^{-4}$ and the macroscopic strain tensor $\bm{\epsilon}$ was calculated from the deformation of the periodic cell boundaries [@Smith2014]. We restrict our analysis to the first and second invariants of the tensor: volumetric strain $\epsilon_{v}=\frac{1}{3}\sum_{k}\epsilon_{kk}$ and deviatoric (shear) strain $\gamma = \sqrt{\frac{3}{2}\sum_{i,j}\left(\epsilon_{ij}-\epsilon_{v}\delta_{ij}\right)}$, where $\delta_{ij}$ is the Kronecker delta tensor. The evolution of deviatoric strain with time is well described by two-stage dynamics represented phenomenologically by: $$\gamma(t)=\gamma_{0}\left(1-e^{-t/\tau_{1}}\right) + \gamma_{1}\text{log}\left(\frac{t}{\tau_{2}}+1\right),
\label{eq3}$$ where $\tau_{1}$ is a viscoelastic time constant, and $\tau_{2}$ sets the timescale for slow dynamics. Fig. \[global\](a) displays the evolution of deviatoric strain with time (normalized by the fast dynamics time constant $\tau_{1}$) at four different compressive stresses and the same jamming pressure. Black lines indicate best fits to Eq. \[eq3\], and good agreement is observed at both long and short times. The first term of Eq. \[eq3\] denotes an initial Kelvin viscoelasticity in which $\gamma_{0}$ is the total elastic strain that is delayed by a viscous time constant $\tau_{1}$ [@Findley:1976aa]. The second term corresponds to a logarithmic creep that is caused by long-term structural rearrangements and this phenomenon has been previously observed in colloidal glasses [@Siebenburger2012] and dense granular materials [@Nguyen2011; @Amon2012]. Such distinct relaxation regimes corresponding to fast and slow dynamics has been previously reported in experiments on granular compaction [@Knight1995; @Brujic2005].

The granular packings exhibit rapid compaction at short times, whereas slow dilation occurs at longer times (see Fig. \[global\](b)). Because the variable-cell method enables full tensorial evolution of strain while maintaining a constant external stress, the temporal response of transverse and axial strains at all times can be predicted (see inset of Fig. \[global\](b)). At short times the transverse tensile strain $\left(\epsilon_{yy}+\epsilon_{zz}\right)$ is negligible, and rapid granular compaction is caused entirely by axial compression $\epsilon_{xx}$. During slow creep the tensile transverse strain competes with the compressive axial strain and results in slow dilation within the packing. This prediction correlates well with experimental observations during displacement pile setup in dense sands—comprised of angular grains—in which an initial volumetric contraction was followed by a long-term kinematically restrained dilation [@Bowman2005].

![\[local\] (a) Deviations in the compressive strain $\epsilon_{xx}$ along a [*[xy]{}*]{}-plane at three times (left to right: $t=30\tau_{1}$, $60\tau_{1}$ and $100\tau_{1}$) relative to a reference configuration at $t=20\tau_{1}$ in the slow regime. White and green circles indicate growing regions of extensional and compressive strain respectively. (b) Probability distributions of local compressive strains $\epsilon_{xx}$. The solid lines are Gaussian fits \[inset: non-gaussian parameter $\alpha$ at various time intervals\]. (c) Spatial correlation function of local deviatoric strain $C_{\gamma}(r)$ for three time intervals (see (a)) as a function of radial distance $r$ normalized by the in-sphere diameter $d_p$ of an octahedral grain \[inset: normalized correlation length $\xi$ at various time intervals\].](Fig2)

#### Heterogeneous Micromechanics.

To understand the microscopic mechanisms that govern global creep response, the complex spatio-temporal granular dynamics were decomposed in terms of local structural rearrangements. A time-dependent local strain for grain $i$ was determined by the best-fit affine matrix $\mathbf{F}_{i}$ that transforms the center-to-center vectors $\mathbf{r}_{ij}$ of $n$ contacting grains over a time step of $\Delta t$ by minimizing $D_{i}^{2} = \sum_{j=1}^{n}\left[\mathbf{r}_{ij}\left(t+\Delta t\right) - \mathbf{F}\mathbf{r}_{ij}\left(t\right)\right]^2$ [@Falk1998] . A symmetric Lagrangian strain tensor can then be calculated as $\bm{\epsilon}_{i}=\frac{1}{2}\left(\mathbf{F}_{i}^{T}\mathbf{F}_{i}-\mathbf{I}\right)$. The remaining non-affine component of motion $D_{i}^{2}$ represents a component of the granular motion in the system that is elastically irreversible.

In the regime of slow granular creep, a growing heterogeneity of the local strain field is observed. With a reference configuration at $t=20\tau_{1}$, we focus on the deviations of the uniaxial strain component $\epsilon_{xx}$ (parallel to the global uniaxial strain) along a [*[xy]{}*]{}-plane of the packing and illustrate its distribution relative to the reference configuration for $t=30\tau_{1}$, $60\tau_{1}$ and $100\tau_{1}$ in Fig. \[local\](a). The grains are color-coded based on the local uniaxial strain. White and green circles indicate regions of tensile and compressive uniaxial strain, respectively. We observe that the regions of negative and positive strain extend over many grains, and the spatial extent of these regions grows with time. Furthermore, the regions of positive (negative) strain are more positively (negatively) strained with the progress of time, as indicated within the white (green) circles. These regions indicate zones of large strain localization that are analogous to shear transformation zones in other amorphous materials [@Schall2007; @Wang2013].

The distribution of local strains broadens with time, as shown in Fig. \[local\](b). Furthermore, the strain distribution becomes less Gaussian with time, as indicated by the non-Gaussian parameter $\alpha(\Delta t)$ in the inset of Fig. \[local\](b). This phenomenon is a signature of increasingly correlated transformations wherein localized deformations are coupled across multiple grains. To quantify this coupling, we compute the spatial autocorrelation of local deviatoric strain $\gamma$, defined as: $$C_{\gamma}(\Delta r) = \frac{\langle \gamma(r+\Delta r)\gamma(r)\rangle -\langle\gamma(r)\rangle^{2}}{\langle \gamma(r)^{2}\rangle - \langle \gamma(r)\rangle^{2}},
\label{eq4}$$ where angular brackets denote ensemble averages. As shown in Fig. \[local\](c), as time progresses in the slow creep regime, the local strains become more spatially correlated with an increasing correlation length as indicated in the figure inset. The correlation length is defined as the radial distance at which the autocorrelation goes to zero (denoted with dashed lines in the figure). This correlated deformation has been previously identified as a signature of the elastic response of glassy materials to local shear transformation zones [@Jensen2014] via stress redistributions caused by Eshelby fields [@Chattoraj2013].

![\[motion\] (a) Temporal evolution of the ensemble average of local deviatoric strain rate $\langle \dot{\gamma}_{i} \rangle$ (black), non-affine velocity $\langle \dot{D}_{i} \rangle$ (green) and rotational velocity $\langle \dot{R}_{i} \rangle$ (red) as a function of time. (b) Accumulated non-affine motion $S(t)$ as a function of global deviatoric strain $\gamma(t)$ for four uniaxial compressive stresses (see legend) and a jamming pressure $P=2\times 10^{-5}$. The solid black lines are linear fits. Inset: Scatter plots of the accumulated non-affine displacements divided by the applied uniaxial compressive stress for two different jamming pressures. Red circles represent data from the main graph. Blue rectangles represent data for $P=1 \times 10^{-4}$ and applied uniaxial stresses: $\sigma_{\text{ext}} = 1\times 10^{-7}$, $2\times 10^{-7}$, $3\times 10^{-7}$ and $4\times 10^{-7}$.](Fig3)

#### Evolution of Plastic Activity.

To elucidate the correlations between macroscale creep and local transformations, we quantify the temporal evolution of local dynamics at the grain scale by calculating the ensemble average of local deviatoric strain rate $\langle\dot{\gamma}_{i}\rangle$, non-affine velocity $\langle \dot{D}_{i} \rangle$ and rotational velocity $\langle \dot{R}_{i} \rangle$ as functions of time. Granular rotation is quantified by the magnitude of the rotation of a grain about its instantaneous axis of rotation that is given by the cross product of unit vectors that connect the grain centroid to a specific vertex between consecutive time steps.

Fig. \[motion\](a) shows that at short times, when the macroscopic dynamics are exponential ($t \ll \tau_{1}$), local mechanical transformations are caused almost entirely by affine elastic deformations in the packing, as indicated by large shear strain rates and low non-affine and rotational velocities. This result indicates that the early transformations are essentially elastic in nature with little irreversibility in the granular motion. However, as the granular packing transitions into the logarithmic slow creep regime ($t \sim \tau_{1}$), it experiences increased irreversibility as evidenced by a decrease in local shear strain rates, and an increase in the non-affine and rotational velocities. During long periods of slow creep ($t \gg \tau_{1}$), both the elastic and non-affine contributions to local deformations decay slowly as the system creeps towards a metastable state. The close association between the growth of local non-affine transformations and the evolution of slow macroscopic creep indicates the presence of a causal relationship.

This relationship was further explored by correlating the temporal accumulation of squared non-affine displacements with the temporal evolution of macroscopic strain. Quantitatively, this accumulation at any time $t$ is computed as $S(t) =  S(t-\Delta t)+ \langle D_{i}^{2}\left(t-\Delta t,t\right) \rangle$, where the angular brackets denote the ensemble average of $D_{i}^{2}$ recorded between times $t-\Delta t$ and $t$. Fig. \[motion\](b) displays the relationship between cumulative non-affine displacements and macroscopic creep strain. The relationship is linear (except at short times), and the slope decreases with decreasing magnitude of applied uniaxial stress. Furthermore, all the curves collapse to a single linear curve when $S(t)$ is divided by the applied stress $\tau$ (see inset for two jamming pressures). This relationship can be expressed as $S(t) \sim \sigma_{\text{ext}} \gamma(t)$, and it reinforces the evidence that local irreversible deformations play a dominant role in the global creep process. We also note that for granular systems, jamming pressure plays a crucial role in plastic dissipation. From the inset of Fig. \[motion\](b), the scale of plastic dissipation per unit elastic relaxation is larger in systems jammed under larger hydrostatic pressure. This result is expected because the large elastic modulus of highly jammed grains increases elastic coupling between plastic events.

Lastly, we provide a mechanical definition for $S(t)$ by considering $\sigma_{\text{ext}} \gamma(t)$ to represent the elastic energy density released in the bulk during the creep relaxation process at long times. In athermal systems, elastic energy relaxation should be balanced by plastic dissipation in the system. Therefore, $S(t)$ represents the scale of plastic dissipation density in the system that is driven by external stress and manifests itself in the form of non-affine granular displacements. External stress-facilitated accumulation of non-affine displacements was also previously demonstrated for thermally driven amorphous metallic glass systems [@Wang2013].

#### Conclusion.

This letter identifies the internal structural transformations that govern the creep relaxation of uniaxially compressed granular solids. A full tensorial analysis of the system dynamics, enabled by a variable-cell simulation method, provides constitutive prediction of the temporal evolution of deviatoric and volumetric strains at all scales. The simulations predict rapid uniaxial compression at short times followed by slow dilation at long times. The accumulation of irreversible granular motion is proposed as a micromechanical explanation for slow logarithmic creep and is directly correlated with the plastic dissipation density within the system. Importantly, a simplified mean-field dissipation model captures the slow logarithmic creep dynamics observed in real granular solids [@Nguyen2011] and glassy colloids [@Siebenburger2012], thereby indicating a universality in the role of localized plasticity during slow relaxation of amorphous solids. Future work will focus on the effects of more complex grain shapes and inter-granular friction on creep relaxation processes.

#### Acknowledgements.

This work was supported by Grant No. 1344654 from the National Science Foundation Scalable Nanomanufacturing Program. We also acknowledge useful discussions with Prof M. Ashraf Alam.

[^1]: See Supplemental Material for detailed derivation and dimensional analysis of the equations of motion.


Follow

Top 10 of 2016. Number 5: Kute Blackson

On Today’s Show

We’re counting down the top 10 episodes of 2016 on the 1 Simple Thing podcast. Today is number 5 on the list. Episode 569: Love Now. We hope you enjoy it and Happy New Year!

Kute Blackson reveals the real purpose and power behind everything we do…love. But how do we bring love and peace in the world if there’s no love and peace in ourselves? How do we bring love and community in the world if there’s no love in our hearts for ourselves? At the end of our lives, everything boils down to this: did you love fully or did you spend your life holding back?

Here’s the bottom line: THIS is the moment is all we have. This is it. Every single second of our life is the moment you’ve been waiting for, and every moment of your life is an opportunity to love.

1 Simple Thing Action

Make a fierce commitment to love, moment to moment. Sit with death and realize that you are going to die. Feel your death. Face your death. And let that inspire you to realize that we don’t have any time. When you forgive, you set yourself free. Who have you held grudges against? Who have you not forgiven? Who do you need to communicate with or apologize to? Who do you need to express love to? Do it right now.


My local cable monopoly has decided to move MSNBC to a premium level so only the wealthy can afford to watch Maddow dissect right-wing narratives. I’ve written doggerel for the occasion:

Now look at them yo-yo’s that’s the way you do it

You play the race card on the Fox TV

That is workin’ that’s the way we do it

Teabaggers marchin’ on Fox TV

Now that is workin’ that’s the way we do it

Local rednecks, them guys are dumb

Beck can do the wacky on your little wingers

Bill-O gets em twisted up and numb

We gotta install fear of the other

Custom lobby derivatives

We gotta lose these equivocators

We gotta own their colour TV’s

See the little maggot with the wiring and the makeup

Yeah buddy that’s his own hair

That bigger maggot wants his own pro ball team

And Rupert Murdoch is a billionaire

We gotta instill fear of the other

Custom lobby derivatives

We gotta lose these equivocators

We gotta own their colour TV’s

Ailes has learned how to play the race card

Hannity’s learned to beat the drums

Look at that blah blah, we got it comin out the camera

Man this is a lotta fun

And he’s up there, what’s that? Hawaiian noises?

Bangin’ public option like a chimpanzee

Call him liar that’s the way we do it

Money for nothin’ but controversy

We gotta instill fear of the other

Custom lobby derivatives

We gotta lose these equivocators

We gotta own their colour TV’s, Lord

Now that ain’t workin’ that’s the way we do it

They call our bullshit on MSNBC

That ain’t workin’ that’s the way we do it

Call up Comcast and move it to pay feed

Money for nothin’ but controversy

I want my

I want my

Em-e’s-en-bee-cee


Football player goes to court over sexual advancement

On Oct. 26, 2018 a Wyoming football player by the name Youhanna Ghaifan was suspended from the football team and then was later let go from the team. Fort Collins police said that he tried to force himself on an employee at the hotel the team was staying at the evening prior to the Wyoming vs. Colorado State University football game.

Ghaifan was a junior at the University of Wyoming and played defensive tackle. He was charged with two misdemeanors: one of them was for harassment involving a strike along with one charge of false imprisonment.

The incident is believed to be that Ghaifan walked into the room that the housekeeping was cleaning. He closed the door behind him and then approached the woman, asking if she would “like to have some fun”. The girl said no but Ghaifan continued to approach her. He then pinned her to the wall and tried to kiss her.

She was able to get him off of her and then he tried to keep kissing her. She convinced him to leave the room, saying she would come see him in a little bit because she had a break. After Ghaifan left the room she called the police and gave them a description of Ghaifan. Police used that to identify him when they arrived later at the scene.

Ghaifan did not talk to police when they showed up, instead requesting a lawyer. When Ghaifan’s coach and staff found out about the incident they sent Ghaifan back to Laramie. He was unable to play in the CSU game and he was later suspended indefinitely from the football team.

Currently Ghaifan has not been arrested. He has a court date on Dec. 12 for a disposition to determine his plea of guilty or not guilty. If he pleads guilty sentencing will take place at a later date. He is still attending classes on campus and is on track to graduate later this month.

***

Note from Journals.Today : This content has been auto-generated from a syndicated feed.


Q:

Tests fail after Espresso 2 upgrade (failed: Instrumentation run failed due to 'java.lang.IllegalAccessError')

After upgrading Espresso to version 2 none of my unit tests will run on pre-lollipop devices.  See the trace below:
15:07:07.627 [WARN] [org.gradle.api.Project] Tests on Samsung Galaxy S3 - 4.3 - API 18 - 720x1280 - 4.3 failed: Instrumentation run failed due to 'java.lang.IllegalAccessError'
15:07:07.832 [WARN] [org.gradle.api.Project]
com.android.builder.testing.ConnectedDevice > hasTests[Samsung Galaxy S3 - 4.3 - API 18 - 720x1280 - 4.3] FAILED
15:07:07.832 [WARN] [org.gradle.api.Project] No tests found.
15:07:07.834 [DEBUG] [org.gradle.api.Project] DeviceConnector 'Samsung Galaxy S3 - 4.3 - API 18 - 720x1280 - 4.3': uninstalling com.nordstrom.fla.test
15:07:08.252 [DEBUG] [org.gradle.api.Project] DeviceConnector 'Samsung Galaxy S3 - 4.3 - API 18 - 720x1280 - 4.3': uninstalling com.nordstrom.fla
15:07:08.666 [INFO] [org.gradle.api.Project] deleteDir(/Users/graemeharnish/workspace/fla-android/app/build/outputs/reports/androidTests/connected) returned: true
15:07:08.702 [DEBUG] [org.gradle.api.internal.tasks.execution.ExecuteAtMostOnceTaskExecuter] Finished executing task ':app:connectedAndroidTest'
15:07:08.702 [LIFECYCLE] [class org.gradle.TaskExecutionLogger] :app:connectedAndroidTest FAILED

The stack trace is equally unhelpful
* Exception is:
org.gradle.api.tasks.TaskExecutionException: Execution failed for task ':app:connectedAndroidTest'.
    at org.gradle.api.internal.tasks.execution.ExecuteActionsTaskExecuter.executeActions(ExecuteActionsTaskExecuter.java:69)
    at org.gradle.api.internal.tasks.execution.ExecuteActionsTaskExecuter.execute(ExecuteActionsTaskExecuter.java:46)
    at org.gradle.api.internal.tasks.execution.PostExecutionAnalysisTaskExecuter.execute(PostExecutionAnalysisTaskExecuter.java:35)
    at org.gradle.api.internal.tasks.execution.SkipUpToDateTaskExecuter.execute(SkipUpToDateTaskExecuter.java:64)
    at org.gradle.api.internal.tasks.execution.ValidatingTaskExecuter.execute(ValidatingTaskExecuter.java:58)
    at org.gradle.api.internal.tasks.execution.SkipEmptySourceFilesTaskExecuter.execute(SkipEmptySourceFilesTaskExecuter.java:42)
    at org.gradle.api.internal.tasks.execution.SkipTaskWithNoActionsExecuter.execute(SkipTaskWithNoActionsExecuter.java:52)
    at org.gradle.api.internal.tasks.execution.SkipOnlyIfTaskExecuter.execute(SkipOnlyIfTaskExecuter.java:53)
    at org.gradle.api.internal.tasks.execution.ExecuteAtMostOnceTaskExecuter.execute(ExecuteAtMostOnceTaskExecuter.java:43)
    at org.gradle.api.internal.AbstractTask.executeWithoutThrowingTaskFailure(AbstractTask.java:305)
    at org.gradle.execution.taskgraph.AbstractTaskPlanExecutor$TaskExecutorWorker.executeTask(AbstractTaskPlanExecutor.java:79)
    at org.gradle.execution.taskgraph.AbstractTaskPlanExecutor$TaskExecutorWorker.processTask(AbstractTaskPlanExecutor.java:63)
    at org.gradle.execution.taskgraph.AbstractTaskPlanExecutor$TaskExecutorWorker.run(AbstractTaskPlanExecutor.java:51)
    at org.gradle.execution.taskgraph.DefaultTaskPlanExecutor.process(DefaultTaskPlanExecutor.java:23)
    at org.gradle.execution.taskgraph.DefaultTaskGraphExecuter.execute(DefaultTaskGraphExecuter.java:88)

My gradle dependencies
dependencies {
apt "org.robobinding:codegen:$robobindingVersion"
compile "org.robobinding:robobinding:$robobindingVersion:with-aop"
aspectPath("org.robobinding:robobinding:$robobindingVersion:with-aop")

compile 'org.lucasr.twowayview:twowayview:0.1.4'
compile 'com.android.support:support-v4:21.0.3'
compile 'com.android.support:recyclerview-v7:21.0.3'
provided 'com.android.support:appcompat-v7:21.0.3'
compile 'net.hockeyapp.android:HockeySDK:3.5.0-b.4'
compile 'me.dm7.barcodescanner:zbar:1.5'
compile 'com.squareup.picasso:picasso:2.4.0'
compile 'com.squareup:otto:1.3.5'

compile 'org.apache.commons:commons-lang3:3.0'

compile 'com.nispok:snackbar:2.8.0'

compile 'com.rengwuxian.materialedittext:library:1.8.0'
compile 'com.crittercism:crittercism-android-agent:+'

provided 'org.roboguice:roboblender:3.+'

compile 'com.android.support:cardview-v7:21.0.+'
compile 'com.melnykov:floatingactionbutton:1.1.0'

compile 'com.google.code.findbugs:jsr305:1.3.9'
compile 'com.android.support:support-annotations:21.0.3'

androidTestCompile 'com.android.support.test.espresso:espresso-core:2.0'
androidTestCompile 'com.android.support.test:testing-support-lib:0.1'
androidTestCompile 'com.android.support.test.espresso:espresso-contrib:2.0'

androidTestCompile('org.mockito:mockito-core:1.9.5',
        'com.google.dexmaker:dexmaker-mockito:1.1',
        'com.google.dexmaker:dexmaker:1.1')

}
What's strange is it work on 5.0 devices no problem.

A:

Older devices have problems running tests when you have the same dependency in your app and test app that instruments the app.
To work around this issue, you will have to figure out which dependencies cause the problem.
In my case it was both Dagger and Espresso depending on javax.inject and this is how it can be "fixed":
androidTestCompile('com.android.support.test.espresso:espresso-core:2.0') {
    exclude group: 'javax.inject'
}

If you include more or weirder dependencies, you may have a look at this build.gradle.
When using espresso-contrib, you may need to do this:
androidTestCompile('com.android.support.test.espresso:espresso-contrib:2.0') {
    exclude group: 'javax.inject'
    exclude group: 'com.android.support'
}

A:

The problem usually happens when the same dependencies are included more than once or with different versions.
I have a working project using espresso2 with multidex for api level 14+.
Check this SO question . The accepted answer helped a lot.
Mostly, using the ./gradlew -q :myproject:dependencies you can check for duplicate dependencies or the same dependency with different versions included more than once.
This is an example of my espresso dependencies, but I had to change and exclude many:
....
//Espresso 2
androidTestCompile('com.android.support.test.espresso:espresso-core:2.0') {
    exclude group: 'com.google.guava'
    exclude module: 'espresso-idling-resource'
}
androidTestCompile('com.android.support.test:testing-support-lib:0.1') {
    exclude group: 'com.google.guava'
    exclude module: 'espresso-idling-resource'
}
testingCompile ('com.android.support.test.espresso:espresso-contrib:2.0') {
    exclude group: 'com.google.guava'
    exclude group: 'com.android.support', module: 'support-v4'
}
// Need to exclude this when running test
androidTestCompile('com.android.support:multidex-instrumentation:1.0.1') {
    exclude group: 'com.android.support', module: 'multidex'
}
....

The ./gradlew -q :myproject:dependencies will give you an output like the following for every variant+flavour combination:
_prodTestingTestApk - ## Internal use, do not manually configure ##
+--- com.android.support.test.espresso:espresso-core:2.0
|    +--- com.squareup:javawriter:2.1.1
|    +--- org.hamcrest:hamcrest-integration:1.1
|    |    \--- org.hamcrest:hamcrest-core:1.1
|    +--- org.hamcrest:hamcrest-library:1.1
|    |    \--- org.hamcrest:hamcrest-core:1.1
|    +--- javax.inject:javax.inject:1
|    +--- com.android.support.test:testing-support-lib:0.1
|    |    \--- junit:junit-dep:4.10
|    |         \--- org.hamcrest:hamcrest-core:1.1
|    +--- com.google.code.findbugs:jsr305:2.0.1
|    +--- javax.annotation:javax.annotation-api:1.2
|    \--- org.hamcrest:hamcrest-core:1.1
+--- com.android.support.test:testing-support-lib:0.1 (*)
\--- com.android.support:multidex-instrumentation:1.0.1

A:

I had similar problem when I was operating on RecyclerView in my tests which was solved by adding below code to build.gradle:
configurations {
    androidTestCompile.exclude group: 'com.android.support', module: 'recyclerview-v7'
}

And also you can try to add following exclude as well:
configurations {
    androidTestCompile.exclude group: 'com.android.support', module: 'support-v4'
}

So, my configurations in build.gradle looking like that:
configurations {
    androidTestCompile.exclude group: 'com.android.support', module: 'support-v4'
    androidTestCompile.exclude group: 'com.android.support', module: 'recyclerview-v7'
}

This solved both of the issues I faced with: java.lang.IllegalAccessError: Class ref in pre-verified class resolved to unexpected implementation and java.lang.NoClassDefFoundError. After that I was able to run tests on pre-lollipop devices.


1. Field of the Invention
The invention relates to a film laminate from which bag packagings with an integrated film handle can be produced in a form-fill and seal bag machine.
2. The Prior Art
Within the scope of the invention, a packaging machine that works according to the so-called VFFS (vertical form fill sealing) method is referred to as a form-fill and seal bag machine. In such a bag machine that works according to the VFFS principle, the film laminate is formed into a sleeve, and sleeve sections are filled with product and sealed with sealing seams. During the entire process, the material web that forms the sleeve is moved vertically downward. VFFS form-fill and seal bag machines are primarily used for packaging solids in powder and granulate form, for example dry food for animals. They have high machine speeds, and allow efficient production and filling of bags for pourable products.
Bags that have been formed and filled in VFFS form-fill and seal bag machines can have handle punch-outs in the head region, which are introduced during the VFFS process in the form-fill and seal bag machine. A disadvantage of these bags is an often difficult combination of the handle punch-outs, placed at the head side, with opening aids, for example perforations. Also, formation of a simple removal opening is made difficult by handle punch-outs on the head side.
Therefore, bags that have a handle loop in a side surface configured as a side fold are preferably used. The handle loop is glued on or sealed on using measures known from practice. Such handle configurations hinder processing of the film laminate in a VFFS form-fill and seal film machine. In most cases, the machine speed of the form-fill and seal bag machine is so greatly impaired by affixing the film handles that the machine no longer works efficiently. For numerous bags, for example in the animal food sector, pre-finished bags are therefore used, which are individually passed to a filling machine and filled. However, producing these pre-finished bags and filling them is significantly more expensive than producing and filling bags in VFFS form-fill and seal bag machines.
Side-fold bags that have a film handle integrated into the side fold are described in German Utility Model No. DE 84 28 169 U1. The known side-fold bags are pre-finished as individual bags and filled with the material to be packaged, in a separate filling system. The bag wall of the side-fold bags consists of a film laminate that has an imprintable outer film and a sealable film glued to the outer film. In the region of a side fold, a reinforcement sheet has been laminated in between the sealable film and the outer film; this sheet is glued only to the outer film. The film handle is formed by introducing parting cuts that pass through the outer film and the reinforcement sheet connected with the outer film. The sealable inner film of the packaging remains intact and seals off the interior of the bag packaging. The handle loop formed by parting cuts makes a transition into the bag wall at its ends, in one piece with the wall.
International Application No. WO 2008/038308 A1 relates to bag packagings with an integrated handle, which are produced from a two-ply film laminate. The film laminate has an imprintable outer film as well as a sealable film glued to it. In the handle region, the outer film and the sealable film that lies on the inside are not glued together. Handle punch-outs are introduced into the outer film, so that the outer film forms a handle loop. However, the handle loop is not reinforced and therefore is only suitable for packaging products that have a low weight.


Comparison of calculated low density lipoprotein cholesterol (LDL-C) values in HIV-infected and HIV-uninfected men using the traditional Friedewald and the novel Martin-Hopkins LDL-C equations.
Compared to those without human immunodeficiency virus (HIV) -infection, those that are HIV-infected are 1.5 to 2 times more likely to develop atherosclerotic cardiovascular disease (ASCVD) and to do so at a younger age. This increased risk is due to traditional risk factors (e.g., hypertension, diabetes, smoking and dyslipidemia), but also to factors related to HIV infection and antiretroviral therapy (ART). Using the Martin-Hopkins equation to calculate low-density lipoprotein cholesterol (LDL-C) is more accurate than the traditional Friedewald equation, especially at higher triglyceride levels, which are more common in HIV-infected people. Thus, using LDL-C values calculated by the Martin-Hopkins equation may improve clinical care of people living with HIV.


No injuries in Sabhan factory fire; 3 Asians arrested on airport

KUWAIT: Firefighters tackle a blaze at a Subhan factory yesterday.

KUWAIT: A fire was reported yesterday in a furniture factory in Sabah, and it was tackled successfully by firemen from the Sabhan, Mubarak Al-Kabeer, Salmiya, Ardhiya and back up fire stations. The isolated area around the factory kept the fire from spreading. No injuries were reported in the blaze which completely destroyed the 4,000 sq m factory. Meanwhile, investigations are underway to find out the reason behind the fire.

Arrests
Airport security arrested three Asians; one without an ID and wanted by police, another for being reported absconding and the third for being banned from entering Kuwait. They were sent to Jleeb Al-Shuyiukh police station for further legal action.

Deported
Residency detectives deported 18,866 law violators so far this year and recorded 32,627 absconding complaints in cooperation with service centers. The number of security restrictions of expatriates’ missing passport was 1,804.

At large
An SUV driver escaped from police with the help of four persons who got in the way of a patrol and hit it deliberately. One of them then threw an axe at the patrol car and broke its window. Detectives are working on arresting the five, who are still at large.

Impounded
An Egyptian man borrowed a citizen’s car, only to have it impounded because he committed a traffic violation. When the Egyptian told the car owner about it, he beat him up. The Egyptian told Salmiya police what happened, and submitted a medical report as he lodged a complaint. Detectives summoned the citizen, who claimed the Egyptian was lying, but it was proved that he did beat him, so he was referred to concerned authorities for further legal action.

Negligence
Two young women, a citizen and a bedoon (stateless), were arrested after they were found sitting in the street near a Rumaithiya park. Both of their families were called to take back the girls, and they signed undertakings not to leave them outside. A police patrol saw the two girls after midnight. When asked why they were out this late, they said they spend the weekends together. Both girls were taken to the police station, then the citizen’s mother and the bedoon’s elder sister came and took them. They were told they will face charges of negligence in caring for minors if this is repeated.

Cross-dresser
Hawally police stopped a cross-dresser from going to a party, and he was taken to the vice detectives department, where he was detained. The man was in a car with tinted windows, so he was stopped. Police found he was dressed in women’s clothes with makeup and accessories.

Wanted
A citizen went to Mubarak Al-Kabeer police station to lodge a complaint, and because he did not have his ID on him, his fingerprint was taken and he was found wanted on a financial case worth KD 8,000. Police registered his complaint, then he was detained and referred to the civil implementation department.

Fight
Jahra police broke up a bloody fight in Taima during which two citizens ganged up against a third and caused him several injuries. Paramedics were called and the injured man was taken to Jahra Hospital, while and the other two were taken to the police station.


The news that everyone sent me today (thanks, everyone) is that a South African company called The Unlimited has managed to send data using a carrier pigeon faster than by using Telkom's (largest South African ISP) ADSL line.

While interesting, this is not the first attempt at sending digital data via carrier pigeons; in fact, this type of data transfer has been defined (albeit humorously) as IP over Avian Carriers (IPoAC). Here's a bit of background on the story.

IPoAC was described in RFC 1149 (RFC, or Request for Comments, is a document describing some part of the inner workings of the Internet. In short, it's a very technical FAQ for the entire Internet) by the Internet Engineering Task Force (IETF); it was written by D. Waitzman and released on April 1st, 1990. The basic idea behind the "protocol" is strapping some kind of data medium (such as a memory card) on a carrier pigeon's leg and sending it to a remote destination.

IPoAC was first "implemented" (meaning: they actually did it) by the Bergen Linux user group; they sent nine pigeons, each carrying a single ping over the destination of about three miles, but they received only four responses; quite a poor result.

Then, in 2004, a group of Israeli enthusiasts sent three homing pigeons to a destination about 100 kilometers away, with each carrying 20-22 memory cards. The total amount of data transfered was 4 GB, and it took the pigeons below 4 hours, on average, to transfer it.

Finally, yesterday the folks from The Unlimited sent a single 11-month-old pigeon, named Winston, from their offices near Pietermaritzburg to the coastal city of Durban with a data card strapped to his leg. The result? Two hours, six minutes and 57 seconds; by that time, only four percent of the same 4 GB was transfered over the Telkom line.

The lesson? The Internet lines may be getting faster, but the memory card capacity is getting bigger even faster. If you need your data to travel fast, use a carrier pigeon.


Q:

Pass SharePoint Credentials to Access Excel File using Interop?

string url = HttpUtility.HtmlAttributeEncode("https://site.sharepoint.com/sites/Project/Shared%20Documents/ExcelSheet.xlsx");

        Excel.Application xlApp = new Excel.Application();
        Excel.Workbook xlWorkbook = xlApp.Workbooks.Open(url):

This prompts me for an email(userid) and password, I know I can pass the password but how do I get the email(userid) in there.
I also have the SharpePoint credentials saved, I intially tried using the SharepointClient but I got as far as being able download the File, I couldn't figure out how to convert it to an Excel workbook to loop through the cells.
ClientContext context = new ClientContext("https://site.sharepoint.com/sites/Project/"):
SecureString passWord = new SecureString();

 context.Credentials = new SharePointOnlineCredentials(password)

Cheers!

A:

Instead of Excel Interop i would propose to utilize Excel Services REST API which allows to read excel data without any dependencies to external or third party libraries.
Example
The following example demonstrates how to read workbook data from Financial Sample.xlsx sample excel file stored in SharePoint Online Documents library
var credentials = GetCredentials(userName, password);
var client = new ExcelClient(webUrl, credentials);
var data = client.ReadTable("Shared Documents/Financial Sample.xlsx", "Sheet1","A1", "P500");
JObject table = JObject.Parse(data);
int idx = 0;
foreach(var row in table["rows"])
{
     if(idx == 0)
     {
        //skip header
     }
     else
     {
        //get cell values
        var segment = row[0]["v"] as JValue;
        var country = row[1]["v"] as JValue;
        Console.WriteLine("Segment: {0}, Country: {1}", segment.Value,country.Value);
     }
     idx++;
}

where
WebClient class is utilized to consume Excel Services REST
public class ExcelClient : WebClient
{

    public ExcelClient(string webUrl, ICredentials credentials)
    {
        BaseAddress = webUrl;
        Credentials = credentials;
        Headers.Add("X-FORMS_BASED_AUTH_ACCEPTED", "f");
    }

    public string ReadTable(string fileUrl, string sheetName, string cellStart,string cellEnd, string format="json")
    {

        var endpointUrl = BaseAddress + string.Format("/_vti_bin/ExcelRest.aspx/{0}/Model/Ranges('{1}!{2}|{3}')?$format={4}", fileUrl,sheetName,cellStart,cellEnd,format);
        return DownloadString(endpointUrl);
    }

}

and SharePointOnlineCredentials class to access SharePoint Online resources via user credentials
static ICredentials GetCredentials(string userName, string password)
{
    var securePassword = new SecureString();
    foreach (var c in password)
    {
        securePassword.AppendChar(c);
    }
    return new SharePointOnlineCredentials(userName, securePassword);
}

Results

References

Sample URI For Excel Services REST API
Requesting Excel workbook data from SharePoint Server using OData


A mollusk VDR/PXR/CAR-like (NR1J) nuclear receptor provides insight into ancient detoxification mechanisms.
The origin and diversification of the metazoan endocrine systems represents a fundamental research issue in biology. Nuclear receptors are critical components of these systems. A particular group named VDR/PXR/CAR (NR1I/J) is central in the mediation of detoxification responses. While orthologues have been thoroughly characterized in vertebrates, a sparse representation is currently available for invertebrates. Here, we provide the first isolation and characterization of a lophotrochozoan protostome VDR/PXR/CAR nuclear receptor (NR1J), in the estuarine bivalve the peppery furrow shell (Scrobicularia plana). Using a reporter gene assay, we evaluated the xenobiotic receptor plasticity comparing the human PXR with the S. plana NR1Jβ. Our results show that the molluscan receptor responds to a natural toxin (okadaic acid) in a similar fashion to that reported for other invertebrates. In contrast, the pesticide esfenvalerate displayed a unique response, since it down regulated transactivation at higher concentrations, while for triclosan no response was observed. Additionally, we uncovered lineage specific gene duplications and gene loss in the gene group encoding NRs in protostomes with likely impacts on the complexity of detoxification mechanisms across different phyla. Our findings pave the way for the development of multi-specific sensor tools to screen xenobiotic compounds acting via the NR1I/J group.


import math
import itertools
import sys
IS_PYTHON3 = sys.version_info[0] >= 3

if IS_PYTHON3:
    exec('from ._edit_descriptors import *')
    exec('from ._misc import expand_edit_descriptors, has_next_iterator')
    exec('from . import config')
else:
    exec('from _edit_descriptors import *')
    exec('from _misc import expand_edit_descriptors, has_next_iterator')
    exec('import config as config')

PROC_SIGN_ZERO = config.PROC_SIGN_ZERO
PROC_MIN_FIELD_WIDTH = config.PROC_MIN_FIELD_WIDTH
PROC_DECIMAL_CHAR = config.PROC_DECIMAL_CHAR
G0_NO_BLANKS = config.G0_NO_BLANKS
PROC_NO_LEADING_BLANK = config.PROC_NO_LEADING_BLANK

def output(eds, reversion_eds, values):
    '''
    a function to take a list of valid f77 edit descriptors and respective values
    and output the corresponding string
    '''
    record = ''
    state = {
        'position' : 0,
        'scale' : 0,
        'incl_plus' : False,
        'blanks_as_zeros' : False,
        'halt_if_no_vals' : False,
    }

    # if format is empty with no values specified, then output blank record -
    # see section 13.3

    # check that if there is a reversion, that values can be output
    reversion_contains_output_ed = False
    for ed in reversion_eds:
        if isinstance(ed, OUTPUT_EDS):
            reversion_contains_output_ed = True
            break
    # Get full list of edit descriptors
    eds = expand_edit_descriptors(eds)
    reversion_eds = expand_edit_descriptors(reversion_eds)
    # use iterators
    get_ed = has_next_iterator(eds)
    get_value = has_next_iterator(values)
    tmp_reversion_eds = []
    # continue until out of edit descriptors or values
    while True:
        # no more edit descriptors, no more values, stop output,
        # todo: this will cut short a reversion edit descriptor section - is this right?
        if not get_ed.has_next() and not get_value.has_next():
            break
        # take a edit descriptor off the queue if there is any
        if get_ed.has_next():
            if IS_PYTHON3:
                ed = next(get_ed)
            else:
                ed = get_ed.next()
        else:
            if reversion_contains_output_ed == True:
                # take from reversion edit descriptors if there is a value
                # requiring output still
                while True:
                    if len(tmp_reversion_eds):
                        ed = tmp_reversion_eds.pop()
                        # these edit descriptors are ignored in reversion state
                        if not isinstance(ed, NON_REVERSION_EDS):
                            break
                    else:
                        # Regardless of where cursor is, is moved to the
                        # next record
                        record = record + config.RECORD_SEPARATOR
                        state['position'] = len(record)
                        tmp_reversion_eds = reversion_eds[::-1]
            else:
                # ignore the revsion edit descriptors as cannot output the
                # final value
                break
        # check if edit descriptor requires a value
        if isinstance(ed, OUTPUT_EDS):
            if get_value.has_next():
                if IS_PYTHON3:
                    val = next(get_value)
                else:
                    val = get_value.next()
            else:
                # is a edit descriptor that requires a value but no value
                # todo: does it stop gracefully or raise error?
                break
            if isinstance(ed, I):
                sub_string = _compose_i_string(ed.width, ed.min_digits, state, val)
            elif isinstance(ed, B):
                w = ed.width
                m = ed.min_digits
                sub_string = _compose_boz_string(w, m, state, val, 'B')
            if isinstance(ed, O):
                w = ed.width
                m = ed.min_digits
                sub_string = _compose_boz_string(w, m, state, val, 'O')
            if isinstance(ed, Z):
                w = ed.width
                m = ed.min_digits
                sub_string = _compose_boz_string(w, m, state, val, 'Z')
            elif isinstance(ed, F):
                w = ed.width
                e = None
                d = ed.decimal_places
                sub_string = _compose_float_string(w, e, d, state, val, 'F')
            elif isinstance(ed, E):
                w = ed.width
                e = ed.exponent
                d = ed.decimal_places
                sub_string = _compose_float_string(w, e, d, state, val, 'E')
            elif isinstance(ed, D):
                w = ed.width
                e = None
                d = ed.decimal_places
                sub_string = _compose_float_string(w, e, d, state, val, 'D')
            elif isinstance(ed, G):
                w = ed.width
                e = ed.exponent
                d = ed.decimal_places
                sub_string = _compose_float_string(w, e, d, state, val, 'G')
            elif isinstance(ed, EN):
                w = ed.width
                e = ed.exponent
                d = ed.decimal_places
                sub_string = _compose_float_string(w, e, d, state, val, 'EN')
            elif isinstance(ed, ES):
                w = ed.width
                e = ed.exponent
                d = ed.decimal_places
                sub_string = _compose_float_string(w, e, d, state, val, 'ES')
            elif isinstance(ed, L):
                sub_string = _compose_l_string(ed.width, state, val)
            elif isinstance(ed, A):
                sub_string = _compose_a_string(ed.width, state, val)
            state['position'], record = _write_string(record, sub_string, state['position'])
        else:
            # token does not require a value
            if isinstance(ed, (S, SS)):
                state['incl_plus'] = False
            if isinstance(ed, SP):
                state['incl_plus'] = True
            elif isinstance(ed, P):
                state['scale'] = ed.scale
            elif isinstance(ed, BN):
                # This is moot since for output, this does not do anything
                state['blanks_as_zeros'] = False
            elif isinstance(ed, BZ):
                state['blanks_as_zeros'] = True
            elif isinstance(ed, Colon):
                state['halt_if_no_vals'] = True
            elif isinstance(ed, Slash):
                state['position'], record = _write_string(record, config.RECORD_SEPARATOR, state['position'])
            elif isinstance(ed, (X, TR)):
                state['position'] = state['position'] + ed.num_chars
            elif isinstance(ed, TL):
                state['position'] = state['position'] - ed.num_chars
            elif isinstance(ed, T):
                state['position'] = ed.num_chars - 1
            elif isinstance(ed, QuotedString):
                sub_string = ed.char_string
                state['position'], record = _write_string(record, sub_string, state['position'])
    # output the final record
    return record

def _compose_nan_string(w, ftype):
    if ftype in ['B', 'O', 'Z']:
        return ''
    else:
        # Allow at least 'NaN' to be printed
        if w == 0:
            w = 4 # n.b. this is what is set in Gfortran 4.4.0
        if w < 3:
            return '*' * w
    return 'NaN'.rjust(w)

def _compose_inf_string(w, ftype, sign_bit):
    if ftype in ['B', 'O', 'Z']:
        return ''
    else:
        sign = '+'
        # Allow at least 'Inf' to be printed
        if w == 0:
            w = 4
        if w < 3:
            return '*' * w
        # Change sign if negative
        if sign_bit:
            sign = '-'
            # Require sign if negative, if no space then overflow
            if w == 3:
                return '*' * w
        # Output long version if long enough
        if w > 8:
            return (sign + 'Infinity').rjust(w)
        # Output shortened version with sign if long enough
        elif w > 3:
            return (sign + 'Inf').rjust(w)
        # Should only output short version with no sign if positive
        else:
            return 'Inf'

def _compose_float_string(w, e, d, state, val, ftype):
    '''
    Adapted from code in glibfortran which is written in C so is somwhat
    'bit-pushy' in nature. Writes the value to an initial string (buffer)
    and then pulls the subsequent strings from that
    '''
    if (d < 0) or (d is None):
        raise InvalidFormat('Unspecified precision')
    # Make sure they are ints
    d = int(round(d))
    if e is not None:
        e = int(round(e))
    if w is not None:
        w = int(round(w))
    # ==== write_float ==== (function)
    edigits = 4 # Largest number of exponent digits expected
    if (ftype in ['F', 'EN', 'G']) or \
        ((ftype in ['D', 'E']) and (state['scale'] != 0)):
        # Convert with full possible precision
        ndigits = PROC_MIN_FIELD_WIDTH - 4 - edigits
    else:
        # Otherwise convert knowing what the required precision is (i.e. knowing d)
        if ftype == 'ES':
            ndigits = d + 1
        else:
            ndigits = d
        if ndigits > (PROC_MIN_FIELD_WIDTH - 4 - edigits):
            ndigits = PROC_MIN_FIELD_WIDTH - 4 - edigits
    # ==== WRITE_FLOAT ==== (macro)
    # Determine sign of value
    if val == 0.0:
        sign_bit = '-' in str(val)
    else:
        sign_bit = val < 0
    # handle the nan and inf cases
    if type(val) is float and val != val :
        return _compose_nan_string(w, ed)
    Infinity = 1e1000000
    if val in (-Infinity, Infinity):
        return _compose_inf_string(w, ed, sign_bit)
    tmp = abs(val)
    # Round the input if the input is less than 1
    if (ftype == 'F') and (d == state['scale']) and (d == 0):
        if tmp < 1.0:
            tmp = round(tmp)
    zero_flag = (tmp == 0)
    # === DTOA === (macro)
    # write the tmp value to the string buffer
    # sprintf seems to allow negative number of decimal places, need to correct for this
    if ndigits <= 0:
        fmt = '%+-#' + str(PROC_MIN_FIELD_WIDTH) + 'e'
    else:
        fmt = '%+-#' + str(PROC_MIN_FIELD_WIDTH) + '.' + str(ndigits - 1) + 'e'
    buff = fmt % tmp
    # === WRITE_FLOAT === (macro)
    if ftype != 'G':
        return  _output_float(w, d, e, state, ftype, buff, sign_bit, zero_flag, ndigits, edigits)
    else:
        # Perform different actions for G edit descriptors depending on value
        #
        # Generate corresponding I/O format for FMT_G and output.
        # The rules to translate FMT_G to FMT_E or FMT_F from DEC fortran
        # LRM (table 11-2, Chapter 11, "I/O Formatting", P11-25) is:
        #
        # Data Magnitude                              Equivalent Conversion
        # 0< m < 0.1-0.5*10**(-d-1)                   Ew.d[Ee]
        # m = 0                                       F(w-n).(d-1), n' '
        # 0.1-0.5*10**(-d-1)<= m < 1-0.5*10**(-d)     F(w-n).d, n' '
        # 1-0.5*10**(-d)<= m < 10-0.5*10**(-d+1)      F(w-n).(d-1), n' '
        # 10-0.5*10**(-d+1)<= m < 100-0.5*10**(-d+2)  F(w-n).(d-2), n' '
        # ................                           ..........
        # 10**(d-1)-0.5*10**(-1)<= m <10**d-0.5       F(w-n).0,n(' ')
        # m >= 10**d-0.5                              Ew.d[Ee]
        #
        # notes: for Gw.d ,  n' ' means 4 blanks
        #        for Gw.dEe, n' ' means e+2 blanks
        nb = 0
        save_scale_factor = state['scale']
        exp_d = 10 ** d
        if (0.0 <= tmp < (0.1 - 0.05 / exp_d)) or \
            (tmp >= (exp_d - 0.5)):
            ftype = 'E'
        else:
            mag = int(abs(round(math.log10(tmp))))
            low = lambda mag, d : 10 ** (mag - 1) - 5 * 10 ** (-d - 1 + mag)
            high = lambda mag, d : 10 ** mag - 0.5 * 10 ** (-d + mag)
            while tmp < low(mag, d):
                mag = mag - 1
            while tmp >= high(mag, d):
                mag = mag + 1
            assert(low(mag, d) <= tmp < high(mag, d))
            if e < 0:
                nb = 4
            else:
                nb = e + 2
            ftype = 'F'
            w = w - nb
            if tmp == 0.0:
                d = d - 1
            else:
                d = d - mag
                # d = -(mid - d - 1)
            state['scale'] = 0
        out = _output_float(w, d, e, state, ftype, buff, sign_bit, zero_flag, ndigits, edigits)
        state['scale'] = save_scale_factor
        # TODO: this may not be right ...
        if nb > 0:
            if '*' in out:
                out = out + ('*' * nb)
            else:
                out = out + (' ' * nb)
        if len(out) > (w + nb):
            out = '*' * (w + nb)
        return out

def _output_float(w, d, e, state, ft, buff, sign_bit, zero_flag, ndigits, edigits):

    # nbefore - number of digits before the decimal point
    # nzero - number of zeros after the decimal point
    # nafter - number of digits after the decimal point
    # nzero_real - number of zeros after the decimal point regardles of the precision

    # Some hacks to change None to -1 (C convention)
    if w is None:
        w = -1
    if e is None:
        e = -1
    nzero_real = -1
    sign = _calculate_sign(state, sign_bit)
    # Some debug
    if d != 0:
        assert(buff[2] in ['.', ','])
        assert(buff[ndigits + 2] == 'e')
    # Read in the exponent
    ex = int(buff[ndigits + 3:]) + 1
    # Handle zero case
    if zero_flag:
        ex = 0
        if PROC_SIGN_ZERO:
            sign = _calculate_sign(state, sign_bit)
        else:
            sign = _calculate_sign(state, False)
        # Handle special case
        if w == 0:
            w = d + 2
        # This case does not include a decimal point
        if (w == 1) and (ft == 'F'):
            if state['incl_plus']:
                return '*' # This is ifort behaviour
            else:
                return '.' # CHANGED: Was '0'
    # Get rid of the decimal and the initial sign i.e. normalise the digits
    digits = buff[1] + buff[3:]
    # Find out where to place the decimal point
    if ft == 'F':
        nbefore = ex + state['scale']
        if nbefore < 0:
            nzero = -nbefore
            nzero_real = nzero
            if nzero > d:
                nzero = d
            nafter = d - nzero
            nbefore = 0
        else:
            nzero = 0
            nafter = d
        expchar = None
    elif ft in ['E', 'D']:
        i = state['scale']
        if (d <= 0) and (i == 0):
            raise InvalidFormat("Precision not greater than zero in format specifier 'E' or 'D'")
        if (i <= -d) or (i >= (d + 2)):
            raise InvalidFormat("Scale factor out of range in format specifier 'E' or 'D'")
        if not zero_flag:
            ex = ex - i
        if i < 0:
            nbefore = 0
            nzero = -i;
            nafter = d + i
        elif i > 0:
            nbefore = i
            nzero = 0
            nafter = (d - i) + 1
        else:
            nbefore = 0
            nzero = 0
            nafter = d
        expchar = ft
    elif ft == 'EN':
        # Exponent must be a multiple of 3 with 1-3 digits before the d.p
        if not zero_flag:
            ex = ex - 1
        if ex >= 0:
            nbefore = ex % 3
        else:
            nbefore = (-ex) % 3
            if nbefore != 0:
                nbefore = 3 - nbefore
        ex = ex - nbefore
        nbefore = nbefore + 1
        nzero = 0
        nafter = d
        expchar = 'E'
    elif ft == 'ES':
        if not zero_flag:
            ex = ex - 1
        nbefore = 1
        nzero = 0
        nafter = d
        expchar = 'E'
    # Round the value
    if (nbefore + nafter) == 0:
        ndigits = 0
        if (nzero_real == d) and (int(digits[0]) >= 5): # n.b. character comparison not very pythonic!
            # We rounded to zero but shouldn't have
            nzero = nzero - 1
            nafter = 1
            digits = '1' + digits[1:]
            ndigits = 1
    elif (nbefore + nafter) < ndigits:
        ndigits = nbefore + nafter
        i = ndigits
        if int(digits[i]) >= 5:
            # Propagate the carry
            i = i - 1
            while i >= 0:
                digit = int(digits[i])
                if digit != 9:
                    digits = _swapchar(digits, i, str(digit + 1))
                    break
                else:
                    digits = _swapchar(digits, i, '0')
                i = i - 1
            # Did the carry overflow?
            if i < 0:
                digits = '1' + digits
                if ft == 'F':
                    if nzero > 0:
                        nzero = nzero - 1
                        nafter = nafter + 1
                    else:
                        nbefore = nbefore + 1
                elif ft == 'EN':
                    nbefore = nbefore + 1
                    if nbefore == 4:
                        nbefore = 1
                        ex = ex + 3
                else:
                    ex = ex + 1
    # Calculate the format of the exponent field
    if expchar is not None:
        # i = abs(ex)
        # while i >= 10:
        #     edigits = edigits + 1
        #     i = i / 10.0
        if e < 0:
            # Width not specified, must be no more than 3 digits
            if (ex > 999) or (ex < -999):
                edigits = -1
            else:
                edigits = 4
                if (ex > 99) or (ex < -99):
                    expchar = ' '
        else:
            assert(isinstance(ex, int))
            edigits = len(str(abs(ex)))
            # Exponenet width specified, check it is wide enough
            if edigits > e:
                edigits = -1
            else:
                edigits = e + 2
    else:
        edigits = 0
    # Zero values always output as positive, even if the value was egative before rounding
    i = 0
    while i < ndigits:
        if digits[i] != '0':
            break
        i = i + 1
    if i == ndigits:
        # The output is zero so set sign accordingly
        if PROC_SIGN_ZERO:
            sign = _calculate_sign(state, sign_bit)
        else:
            sign = _calculate_sign(state, False)
    # Pick a field size if none was specified
    if w <= 0:
        w = nbefore + nzero + nafter + 1 + len(sign)
    # Work out how much padding is needed
    nblanks = w - (nbefore + nzero + nafter + edigits + 1)
    if sign != '':
        nblanks = nblanks - 1
    # TODO: Find out what this is
    if G0_NO_BLANKS: # dtp->u.p.g0_no_blanks
        w = w - nblanks
        nblanks = 0
    # Check value fits in specified width
    if (nblanks < 0) or (edigits == -1):
        return '*' * w
    # See if we have space for a zero before the decimal point
    if (nbefore == 0) and (nblanks > 0):
        leadzero = True
        nblanks = nblanks - 1
    else:
        leadzero = False
    out = ''
    # Pad to full field width
    if (nblanks > 0) and not PROC_NO_LEADING_BLANK: # dtp->u.p.no_leading_blank
        out = out + ' ' * nblanks
    # Attach the sign
    out = out + sign
    # Add the lead zero if necessary
    if leadzero:
        out = out + '0'
    # Output portion before the decimal point padded with zeros
    if nbefore > 0:
        if nbefore > ndigits:
            out = out + digits[:ndigits] + (' ' * (nbefore - ndigits))
            digits = digits[ndigits:]
            ndigits = 0
        else:
            i = nbefore
            out = out + digits[:i]
            digits = digits[i:]
            ndigits = ndigits - i
    # Output the decimal point
    out = out + PROC_DECIMAL_CHAR
    # Output the leading zeros after the decimal point
    if nzero > 0:
        out = out + ('0' * nzero)
    # Output the digits after the decimal point, padded with zeros
    if nafter > 0:
        if nafter > ndigits:
            i = ndigits
        else:
            i = nafter
        zeros = '0' * (nafter - i)
        out = out + digits[:i] + zeros
        digits = digits[nafter:]
        ndigits = ndigits - nafter
    # Output the exponent
    if expchar is not None:
        if expchar != ' ':
            out = out + expchar
            edigits = edigits - 1
        fmt = '%+0' + str(edigits) + 'd'
        tmp_buff = fmt % ex
        # if not state['blanks_as_zeros']:
        if PROC_NO_LEADING_BLANK:
            tmp_buf = tmp_buff + (nblanks * ' ')
        out = out + tmp_buff
    return out

def _calculate_sign(state, negative_flag):
    s = ''
    if negative_flag:
        s = '-'
    elif state['incl_plus']:
        s = '+'
    else:
        s = ''
    return s

def _swapchar(s, ind, newch):
    '''
    Helper function to make chars in a string mutableish
    '''
    if 0 < ind >= len(s):
        raise IndexError('index out of range')
    return s[:ind] + newch + s[ind+1:]

def _compose_a_string(w, state, val):
    # f77 spec 13.5.11 covers a editing
    val = str(val)
    if w is None:
        output = val
    elif w >= len(val):
        output = val.rjust(w)
    else:
        output = val[:w]
    return output

def _compose_l_string(w, state, val):
    # f77 spec 13.5.10 covers l editing
    try:
        val = bool(val)
    except ValueError:
        raise ValueError("cannot convert '%s' to a boolean" % str(val))
    # single t or f
    if val == True:
        sub_string = 'T'
    else:
        sub_string = 'F'
    # now pad to the specified width
    sub_string = sub_string.rjust(w)
    return sub_string

def _compose_i_string(w, m, state, val):
    # f77 spec 13.5.9.1 covers integer editing
    null_field = False
    # be pythonic in what values to accept, if it looks like an integer, then
    # so be it
    try:
        val = int(val)
    except ValueError:
        raise ValueError("cannot convert '%s' to a integer" % str(val))
    # get the basic string without sign etc.
    int_string = '%d' % int(round(math.fabs(val)))
    # pad if necessary
    if m is not None:
        int_string = left_pad(int_string, m, '0')
        # weird case where if zero width specified and is zero, can have zero space
        if (val == 0) and (m == 0):
            int_string = ''
    # prepend the sign
    if int_string != '':
        int_string = _get_sign(val, state['incl_plus']) + int_string
    # fill the field with blanks if the number takes more room than the width
    # see f77 spec 13.5.9 remark 5.
    if len(int_string) > w:
        int_string = '*' * w
    else:
        int_string = int_string.rjust(w)
    return int_string

def _get_sign(val, incl_plus):
    if val >= 0:
        if incl_plus == True:
            return '+'
        else:
            return ''
    else:
        return '-'

def _compose_boz_string(w, m, state, val, ftype):
    try:
        val = int(val)
    except ValueError:
        raise ValueError("Cannot convert %s to an integer" % str(val))
    # Special case for zero
    if val == 0:
        if m is None:
            return '0'.rjust(w)
        elif w == m == 0:
            return ' '
        elif m == 0:
            return w * ' '
        else:
            s = left_pad('0', m, '0').rjust(w)
            if len(s) > w:
                return w * '*'
    # Normal cases
    s = ''
    if ftype == 'B':
        # Binary case
        if val < 0:
            return '*' * w
        while val > 0:
            s = str(val % 2) + s
            val = val >> 1
    elif ftype == 'O':
        # Octal case
        if val < 0:
            return '*' * w
        s = '%o' % val
    elif ftype == 'Z':
        # Hex case
        # Fortran uses Two's complement to represent negative numbers, this
        # restricts hex values to sys.maxint, if greater than this overflow,
        # however this is not perfoect as sys.maxint is Pythons build maximum
        # rather than the systems bit size which is difficult to find reliably
        # across platforms
        if abs(val) > config.PROC_MAXINT:
            return '*' * w
        if val < 0:
            s = '%X' % ((config.PROC_MAXINT * 2) + 2 + val)
        else:
            s = '%X' % val
    if m is None:
        s = s.rjust(w)
    else:
        s = left_pad(s, m, '0').rjust(w)
    if len(s) > w:
        return w * '*'
    else:
        return s

def _write_string(record, sub_string, pos):
    '''Function that actually writes the generated strings to a 'stream'''''
    new_pos = pos + len(sub_string)
    # pad if required with blanks - i.e. input after a tr edit descriptor - see
    # f77 format sec. 13.5.3
    if pos > len(record):
        record = record.ljust(pos)
        out =  record + sub_string
    elif pos == len(record):
        out = record + sub_string
    elif pos < len(record):
        out = record[:pos] + sub_string + record[new_pos:]
    return (new_pos, out)

def left_pad(sub_string, width, pad_char):
    # Python 2.3 does not have the character argument to rjust
    padding = pad_char * (width - len(sub_string))
    return padding + sub_string


Style Info

Remi Human Hair Extensions

Very affordable human hair extensions. Lightly processed for a natural look, durability and easy care and maintenance. Our qualified craftspeople control the quality during the manufacturing process. Have peace of mind knowing you will not get blended or synthetic mixed hair. Our human hair extensions natural shine and luster is retained by our secret processing. Our human hair extensions have triple sewing technology which allows for strong sewing on track and helps prevent shedding.


PayPal

"more secure" calls PayPal your payment system - all transactions are of course SSL encrypted. PayPal also offers online conflict management. With ZAP you can pay with PayPal and without any fees for you!

Handypay

HandyPay allows you to deposit pre-defined selectable amounts via your Englishmobile phone (similar to SMS). The payment will then be made via your Mobile bill. HandyPay will be charged at no charge!.

EPS

EPS is a service of Giropay and monitors similar to instant transfer your online banking transaction. You incur no fees!

Giropay

Giropay works similar to Sofortüberweisung and monitors your online banking transaction. We charge you no fees!

Bank transfer

The classic bank transfer - just transfer in advance to the ZAP bank account and pay within a few days from your credit! The whole thing for you without fees!

PaySafeCard

The popular anonymous payment method "PaySafeCard" is of course also offered by ZAP. Easily and conveniently online or buy and deposit directly into your ZAP Cashbox at filling stationpurchase and deposit directly into your ZAP Cashbox - without any fees for you!

Bitcoin (Coinify)

The anonymous payment method BitCoin enjoys increasing popularity month after month due to increasing rates. You can also deposit your credit on your to current courses. No feesfor you!

Sofortüberweisung

Immediate bank transfer is a payment method certified by TÜV, your Online-Banking Transaction "monitors" you and informs us if the payment was successful. So the money can be credited immediately. The whole thing without any fees for you!

Call2Pay

A Call2Pay payment is made directly via your German landline telephone. Here you can pay up to 20, - € every 7 days and you will be charged on your phone bill. You will not be charged!

Creditcard

One of the most popular and easiest payment methods is credit card payment.Since this can also be very dangerous, we rely on the well-known provider Stripe and their secure system to process such payments.

Rent Teamspeak 3 Server & MyMusicBot - starting from 2,90 € a month

Your own Teamspeak 3 Server, prepaid or contract incl. DDoS Protection up to 900 Gbit/s. The Teamspeak 3 MyMusicBot from our own development with many features such as the Spotify and Shoutcast interface, exclusively by ZAP for only 3,49€ a month.

Rent VPS - DDoS protected, fail-safe & fast

VPS with Linux, Windows or FreeBSD, prepaid or contract - online right away. Optionally with the popular Gameservercloud Webinterface by ZAP, Plesk 12 or OwnCloud. Your own IP-addresses and total DDoS Control: All attacks and settings at a glance.

Rent Rootserver - prepaid and instantly only with ZAP

Want more power? No problem! Our Xeon X5670 and E5-2667v2 Rootserver Systems provide everything you need to get started. Gameserverhost, Databaseserver or Webserver: ZAP makes it easy with full DDoS control instant installation and, optionally, with Plesk or OwnCloud.

Rent webspace and domains - instant and cheap, for 99 cent!

Simple and versatile with ZAP. Our EasyDNS Modul enables you to link your domains to products at will. No need to set up inconvenient DNS records by yourself - Simply route to the vServer, Gameserver or Webspace at the click of your mouse.

The ZAP ONE-Times - LifeTime Buyserver, GamingPCs and Execute Albums!

What are ONE-Times? It's simple: All products, that you pay in a single payment.Particularly popular - our Minecraft LifeTime Gameserver.Pay once and you get to play for your whole life without any additional costs!Execute Fan? No problem! We have supported Execute for years and are his exclusive distribution partner. You can get his album here as a "Real-Life CD" delivered to your home.Your ZAP Gaming PC made from former servers is extremely affordable. For only a few hundred EUR you can get HighEnd gaming hardware delivered to your doorstep.

Account needed

FiveM Patreon membership required!

Please note: To host more than 32 slots, the feature "OneSync" is required. For this you need a Patreon membership. (At least FiveM Element Club Argentum 💿, for more than 64 slots FiveM Element Club Platinum 🌟).

After booking the membership visit https://keymaster.fivem.net/ and register your server with the same email address as the one used for your patreon membership. Enter the key in your ZAP web interface in the "Settings", we then configure it fully automatically and activate OneSync!

Alternatively set the slot number to "32" under "Settings", then your server starts without OneSync!

Login or register

Log in to your ZAP account or register now. The registration is free, there are no duty of payment. All products are also available as prepaid products. That means, if you do not continue paying your server, it will be closed automatically without any costs.

Logged in successfully!

Your login is being checked..

Confirmation required

Login or register

Register now for free at new ZAP 2.0 Webinterface. All services are now available with "Prepaid" option. Many new features are waiting for you!

Logged in successfully!

Your login is being checked..

Login or register

Forgot your password? No Problem! Just enter your username or e-mail address here. We will send you a link to reset your password.


---
abstract: 'This report is based on the work done together with J.B. Kogut and C.G. Strouthos. We study a Yukawa theory with spontaneous chiral symmetry breaking and with a large number $N$ of fermions near the finite temperature phase transition. Critical properties in such a system can be described by the mean field theory very close to the transition point. We show that the width of the window of non-trivial scaling is suppressed by a certain power of 1/N. Our Monte Carlo simulations confirm these analytical results. We discuss implications for the chiral phase transition in QCD.'
address: 'Institute for Theoretical Physics, SUNY, Stony Brook, NY 11794-3840'
author:
- 'M.A. Stephanov'
title: Ginzburg Criterion for the Chiral Transition
---

Introduction
============

Global symmetries provide important information about the properties of quantum field theories. In QCD with 2 massless quarks the global symmetries form the group: SU$_A$(2)$\times$SU(2)$_V$ $\times$U$_B$(1). This fact, together with the ideas of dimensional reduction and universality gives us a prediction for the long-scale behavior at the chiral symmetry restoration transition in QCD [@PiWi84].

The idea of dimensional reduction is based on the observation that at the second order phase transition a certain correlation length in the system diverges and eventually becomes longer than the extent of the Euclidean time. The long-wavelength fluctuations are then squeezed to a $d-1$ dimensional “pancake”. The universality tells us that the long-wavelength behavior of a system depends on the global symmetry and the dimensionality of the system. In particular, for the QCD with 2 massless quarks one should find O(4)$=$SU(2)$\times$SU(2) exponents at the chiral phase transition [@PiWi84].

Such an argument, based on universality, does not tell us how this universal critical behavior sets in. To answer this question one has to study the dynamics. In this work we study how this universal behavior sets in for theories with large number, $N$, of fermion species.

The fermionic fields, unlike the bosonic, do not survive dimensional reduction. One way to see this is to recall that fermion fields have antiperiodic boundary conditions in the time direction, which suppress fluctuations when their correlation length exceeds $1/T$. In another language, the effective $d-1$-dimensional theory for the bosonic fields near $T_c$ is a classical statistical theory. Fermion fields do not have a classical limit [@St95].

However, the fermions may affect the way that the universal behavior sets in. Several authors observed [@RoSp94; @KoKo94] that in the large $N$ limit the exponents of the finite $T$ chiral transition in the Yukawa model are given by the mean field (MF) theory. Monte Carlo simulations confirmed this result [@KoKo94]. How does it reconcile with the universality arguments? The answer is that the large $N$ description has its region of applicability. The scaling for the correlation length in the window between $1/T$ and $N^x/T$, $x>0$, is indeed given by MF. However, when the correlation length exceeds $N^x/T$ the universal scaling sets in.

The model
=========

To derive the crossover exponent $x$ we study [@KoSt98] a Yukawa theory with large number $N$ of fermion species. It can be thought of as an effective description of degrees of freedom in QCD which participate in chiral symmetry breaking. We choose the symmetry group Z(2) instead of O(4) to simplify the argument. The theory is defined by the Lagrangian: $$\label{yukawa}
{\cal L} = {1\over2}(\partial\phi)^2 + {1\over2}\mu^2\phi^2
+ \lambda\phi^4  + \sum_{f=1}^{N}\bar\psi_f \left(
\partial\hskip -.5em / + {g\phi}
\right) \psi_f$$ and is regularized by some momentum cutoff, $\Lambda$. There are two other important scales in the theory: the temperature, $T$, and the mass $m$ of the thermal excitations of the scalar field. $m$ vanishes at $T_c$. Therefore, near the finite temperature phase transition we have the following hierarchy of scales: $\Lambda\gg T \gg m$.

The renormalization group (RG) evolution of the quartic self-coupling of the scalar field, $\lambda$, from the scale $\Lambda$ to the scale $T$ is governed by the RG equations of the $d$-dimensional quantum Yukawa model. After that, at the scale of $T$, we pass through a crossover region: the fermions and nonzero Matsubara modes of the scalar fields decouple. The evolution below $T$ is governed by the RG equations of the scalar $\phi^4$ theory in $d-1$ dimensions.

If the window of scales between $\Lambda$ and $T$ is wide the renormalized coupling $\lambda$ at the scale $T$, $\lambda(T)$, is close to the infrared fixed point of the $d$-dimensional Yukawa theory. In the large-$N$ limit: $$\label{lambda}
\lambda(T) \sim {(4-d)\ T^{4-d}\over N} \quad\mbox{for} \quad 2<d<4.$$ The case $d=4$ is special. The infrared fixed point is trivial and is approached logarithmically as $\Lambda/T\to\infty$: $\lambda(T) \sim 1/ [N\ln(\Lambda/T)]$. For large $N$ this coupling is small. As we shall see shortly, this is the reason why the non-MF critical region is reached only very close to the phase transition.

The quantitative relation between the size of the non-MF critical region, the Ginzburg region, and certain parameters of a given system is known as the Ginzburg criterion. In superconductors such a parameter is a small ratio $T/E_F$, i.e., the width of the Ginzburg region is suppressed by a power of this parameter. In a field theory with large number of fermions, such as (\[yukawa\]), such a parameter is $1/N$.

The MF approximation breaks down because of self-inconsistency when the fluctuations become large. The size of the corrections to the MF is determined by the value of the effective self-coupling of the scalar field. Since the dimensionality of the coupling of the $d-1$-dimensional scalar theory, $\lambda_{d-1}=T\lambda(T)$, is $5-d$, the MF approximation breaks down when $\lambda_{d-1} \sim m^{5-d}$. From this, and with the help of (\[lambda\]), one obtains the following criterion for the applicability of the MF scaling:

$$m \gg {T\over N^x} \ , \quad x={1\over5-d} \ .
\label{ginzburg}$$

In the special case of $d=4$ one finds: $m \gg T/ [N\ln(\Lambda/T)]$. The Ginzburg criterion (\[ginzburg\]) says that for masses $m$ inside the window $T \gg m \gg T/N^x$ the MF scaling holds, while for smaller masses $m \ll T/N^x$ (i.e., closer to the transition) the non-trivial $d-1$ Ising scaling sets in. We see that the size of this latter, non-trivial critical region is suppressed at large $N$.

Lattice
=======

The strategy we use to confirm our analytical results is the following. First, we show that the behavior at sufficiently large correlation length is given by the universality arguments, which in this case predict Ising $Z(2)$ critical exponents. Second, we identify the boundary of the MF region, test the scaling and extract the exponent $x$.

We discretize the $d=3$ theory (\[yukawa\]) on a cubic $L_s^2\times L_t$ lattice in the following standard way [@HaKoKo93]: $$\begin{aligned}
\label{yukawa-lat}
S &=& {\beta N\over4}  \sum_{{\tilde{x}}}
%- \kappa \sum_\mu \phi_{{\tilde{x}}+\hat\mu}\phi_{\tilde{x}}
%+ \lambda_{\rm lat}\phi_{\tilde{x}}^4
\phi^{2}_{\tilde{x}}
+\sum_{i=1}^{N/2} \Big(
\sum_{x,y} \bar{\chi}^{i}_{x} M_{x,y} \chi^{i}_{y}
\nonumber\\ &&
+{1\over8} \sum_{x} \bar{\chi}^{i}_{x} \chi^{i}_{x}
\sum_{ \langle \tilde{x},x \rangle} \phi_{\tilde{x}} \Big) .\end{aligned}$$

The FSS results
---------------

In order to study the critical behavior on lattices available to us we use the finite size scaling (FSS) method. Unlike previous bulk measurements of the critical exponents, when one has to keep the correlation length much smaller than the size of the box, in the FSS we let the correlation length saturate at the box size. This allows us to reach the Ginzburg region.

The results of the FSS analysis for $L_t=6$ lattices are summarized in Table \[tab:fss\].

  Exponents       FSS       Z(2)    MF
  --------------- --------- ------- -----
  $\nu$           1.00(3)   1       0.5
  $\beta_m/\nu$   0.12(6)   0.125   1
  $\gamma/\nu$    1.66(9)   1.75    2

  : Summary of FSS results and comparison with Ising model and MF scaling behavior.[]{data-label="tab:fss"}

We see that all measured exponents show that the scaling very close to criticality is that of the Ising model in 2 dimensions rather than the MF one.

The crossover exponent $x$
--------------------------

A straightforward way to find the value of $x$ is to study the dependence of the order parameter, $\Sigma$, on $\beta$. Since $\Sigma$ vanishes at the critical point, it can be thought of as a measure of the distance from the criticality. We expect that for sufficiently small $\Sigma$, i.e., close to $\beta_c$, this dependence should be given by a power-law scaling of the 2d Ising model: $\Sigma\sim({\rm const}-\beta)^{1/8}$. For larger $\Sigma$, further away from the criticality, the MF scaling holds: $\Sigma\sim({\rm const'}-\beta)^{1/2}$. For even larger $\Sigma$ we should see the scaling corresponding to the fixed point of the 3d Gross-Neveu model [@HaKoKo93]: $\Sigma\sim({\rm const''}-\beta)^1$. In our simulations we can clearly resolve the MF region with the crossover towards the 2d-Ising region (Figure \[fig:broken\]).

In order to find the exponent $x$ we use the relation: $\xi=1/(2\Sigma)$ valid in the MF region. Using the histogram reweighting method and monitoring the quality of the linear fit as we add or subtract points we find for the boundary of the MF region: $\Sigma_{\rm MF}=0.377(11)$, for $N=4$, $\Sigma_{\rm MF}=0.213(4)$ for $N=12$, and $\Sigma_{\rm MF}=0.168(20)$ for $N=24$. It is clear that the non-trivial 2d-Ising region is squeezed as $N$ increases. The fit $\Sigma_{\rm MF}={\rm const}\cdot N^{-x}$ gives $x=0.51(3)$ which is in agreement with the analytical prediction $x=0.5$ of eq. (\[ginzburg\]).

Discussion and conclusions
==========================

We have shown that a suppression of the critical region occurs in theories with large number of fermion species. The corresponding crossover exponent $x$ can be also determined (\[ginzburg\]).

The role of the fermions is to screen the effective self-coupling of the scalar field, $\lambda$. The strength of this effect depends on two factors: (i) large $N$, and (ii) large window of scales between the cutoff of the effective theory, $\Lambda$, and the temperature, $T$. In QCD there is almost an order of magnitude window between the scale of the spontaneous symmetry breaking $\Lambda\sim 1$ GeV, and $T_c\approx
160$ MeV, which is presumably sufficient to drive the effective self-coupling of the scalar field to its infrared fixed point value at the scale of $T_c$. How small this value is then depends on the number of the fermions (the condition (i)). The value $N_c=3$, though not very large, can be considered large in some cases. One can expect, therefore, that in QCD the width of the critical region, where actual O(4) exponents are observed is suppressed. Further analysis is required to make a quantitative prediction.

[9]{} R. Pisarski and F. Wilczek, Phys. Rev. D29 (1984) 338; K. Rajagopal and F. Wilczek, Nucl. Phys. B399 (1993) 395. M.A. Stephanov, Phys. Rev. D52 (1995) 3746. B. Rosenstein, A.D. Speliotopoulos, and H.L. Yu, Phys. Rev. D49 (1994) 6822. A. Kocic and J.Kogut, Phys. Rev. Lett. 74 (1995) 3109, Nucl. Phys. B455 (1995) 229. J.B. Kogut, M.A. Stephanov, and C.G. Strouthos, hep-lat/9805023. S. Hands, A. Kocic, and J.B. Kogut, Ann. Phys. 224 (1993) 29.


“Listed as a top ten destination to visit in 2015 by Lonely Planet, Lithuania is getting media coverage that will inevitably fuel its popularity as an interesting place for Europeans seeking new destinations for city breaks or alternative holiday destinations.”

This report looks at the following areas:

What is the current socio-economic context in Lithuania and where is the role of tourism for its economy?
What is the state of tourism services and infrastructure, including capacity and performance?
What can we expect from Lithuania’s tourism in the future?
What are the current and future developments that are likely to impact the tourism sector in Lithuania?