First Draft of Global Warming Paper.

Link to the paper here

Interesting Artice on Beyond Standard Model experimental Excesses and 7 KeV Sterlie Neutrinos

Snowmass2021 Cosmic Frontier White Paper: Puzzling Excesses in Dark Matter Searches and How to Resolve Them. Looks at the outstanding terestrial and astrophysics particle excess measurement. The interesting one for me is the 3.5 KeV x-ray line, and the 2-3KeV Xenon 1T electron recoil measurements. This could be one of the sterlie (to standard model) right handed neutrinos, we predicted at 7 KeV. We had it staying stable in matter as the Fermi background to cancel the axial force, but decaying in vacuum. Change in pressure of matter in the central of the galaxy, (upwards, pair producing right neutrinos, one which escapes, or downwards, freeing a right neutrino), would produces right handed neutrinos at 7KeV, which then decay to a left neutrino and an axiphoton. In the presence of matter some of these axial photons could convert to regular photon via interactions with quarks, the amount produced would be rough proportional to the matter density and rate of change in matter density in a region. The Xenon excess could also be due to right handed neutrino, a the Fermi sea of interacting with electrons, via a virtual axiphoton a virtual regular photon and virtual meson, (mainly PI), this would be quite suppressed but we would expect there to be many right handed neutrino in the presence of a fluid of a heavy atom like xenon. We may try a calculation of expected excess in the future.

Rainfall energy input and climate sensitivity

byEarth current average annual rainfall is 39inchs. So multiply the volume of water falling per square meter, 970kg, the specific heat of water times the average 82.5 degree plus the heat of vapourization, gets 2.526GJ per year, or 80.11 Watts per square meter. Entering in our formula derived last time.

Where the 1, is the base climate sensitive as Wikipedia. The the 0.07, is the exponient of the increase in rainfall due to each extra degree of heat increase. Thus for every 6.6 Watts per square meter the atmosphere absorbs due to C02, 1W goes into raising the temperature one degree, and 5.6W goes into increasing rainfall. Given we before numerically calculated, that doubling CO2 to 800 parts per million (volume), absorbs 1.1 Watts per square meter. The actually amount of temperature rise is only, 0.167 degrees (Kelvin or Celesis).

Form of Climate Sensitivity including rainfall.

The standard climate sensetivity calculation (See note 2), is depends on T^3. but by Stefan Boltzmann law, but so does the radiation absorbed by any greenhouse gas. This leads to some people worrying about climate runaway boiling off the ocean. But any temperature increase lead to increased rainfall. Wikipedia quotes the sensitivity as about 1 Degree C per (Watt per square meter)). The 80inch of rainfall per year at the equator is equivalent to around 140 W per square meter going into latent heat (and then radiated above the lower atomosphere). Every 1 degree increase in temperature increases rainfall by 7% . So the climate sensitivity formule is of the form.

Where E_rf is the energy of evapouration of the water returned as rainfall per square meter. Due to the exponiential in temperature, the climate sensitivity rapidly decreases as the temperature increases and will never lead to thermal runaway. It remains to measure the current rainfall by latitude and compute the average over the earth. Which I will post later. If the entire rainfall was at the 80 inch per year, equator level climate would be reduce by a factor of 21, so this is a very significant effect, that greatly lessens the results of emissions of CO2.

A Global Warming Calculation. Doubling CO2 to 800ppmv makes one fifth of a degree warming.

So since around COP26, in some of my spare time. I calculated just how much CO2 (and water vapour), absorbs heat radiation from earth. Based on the 3 (4 for H20) strongest absorption lines in the HITRAN database that come from absorption of a photon by the ground state. Going from 400 ppvm CO2 to 800 ppvm, increases absorbtion by just 1.1 Watts per square meter. Below is the chart of absorption by part per million watts of CO2 in the atmosphere.

I have made the code public, at my github. Finishing off a paper with the details of the calculation, but it is basically integrating over latitude, frequency and height, the absorption line and line width with a Lorentzian Line shape. Lorentz is known to be larger than actually absorption at frequencies away from the peak, so this is an over estimate. So how much heating does the extra 1.1 Watts cause. If all the heat goes into the emission, then by Stefan Boltzaman, https://en.wikipedia.org/wiki/Climate_sensitivity, Note 2, 1 Watt is 1 Kelvin (or C) warming. But that for any warming, some of that heat going into evaporating water, so the temperature change well be lower. I will look at evaporation at a later time. Updating this post, now I have done climate sensitivity including rainfall calculation, while the naive temperature increase is about 1.1Kelvin, with rainfall it is only a sixth of that about 0.167 Kelvin.

100 days of data at Dresden-II on elastic neutrino interaction with nucleii.

https://arxiv.org/abs/2202.10829, Bounds on new physics with data of the Dresden-II reactor experiment and COHERENT Coloma et al.

Therefore, current data from these experiments is not enough by itself to impose meaningful constraints on the complete parameter space of NSI with quarks, if considered in full generality

Maybe in 3 years, a thousand days of data, will yield something on non standard interaction. The above paper does yield limits on neutrino magnetic moments. Another paper today,https://arxiv.org/abs/2202.10622, Implications of the first evidence for coherent elastic scattering of reactor neutrinos, Liao, Lui and Marfatia. Yields.

If the standard Lindhard model correctly describes the quenching factor, the data may indicate a light vector or scalar mediator, or a large neutrino magnetic moment. We await more data

Need a Multithreaded Numerical Integrator in Java - See below

In Java, the quickest Thread Exector for Thread that run many times in the Fork Join Pool. You can speed up your numerical integration on multicored CPU like most computers are today. Here it is in Git Hub If we define a function

public abstract class DoubFunction {


    abstract double evalInner(double x, double params[], int i);

    public double eval(double x, int i, double ...params){
        return evalInner(x,  params, i);
    }

}

Then example Simpson Rule Integrates in Java are. With 16 Java Threads on AMD Ryzen with 8 Cores 16 CPU Threads, Standard Integrate takes 51.4 sec, and the ThreadIntegrator only 32.5 seconds.

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicReference;

public class SimpsonsRule {

    private static double third = 1.0/3.0;

    private static int THREADS = 16;

    public static double integrateThreaded(double a, double b, int N, DoubFunction f, double ...params) {         // precision parameter
        double h = (b - a) / (N - 1);     // step size
        ForkJoinPool pool = new ForkJoinPool(THREADS);
       AtomicDouble sum = new AtomicDouble();
        for(int i=0; i {
                double mul = ii%2==0? 2*third: 4*third;
                if (ii==0) { mul = third; }
                if (ii==N-1){ mul = third; }
                double mul1 = mul;
                double x = a + h * ii;
                double fi = f.eval(x,ii, params);
                if (Double.isNaN(fi) ){
                    System.err.println(f.getClass().getName() + "IS NaN at "+x);
                }
                sum.getAndAdd(mul1*fi);
            });
        }
        try {
            pool.shutdown();
            if (!pool.awaitTermination(1, TimeUnit.HOURS)){
                pool.shutdownNow();
            }
        } catch (Exception e){}
        return sum.getAndAdd(0.0) * h;
    }

    public static double integrate(double a, double b, int N, DoubFunction f, double ...params) {         // precision parameter
        double h = (b - a) / (N - 1);     // step size
        double fa = f.eval(a,0, params);
        double fb = f.eval(b, N-1, params);
        if (Double.isNaN(fa) ){
          System.err.println(f.getClass().getName() + "IS NaN at "+a);
        }
        if (Double.isNaN(fb)){
            System.err.println(f.getClass().getName() + "IS NaN at "+b);
        }
        // 1/3 terms
        double sum = third * (fa + fb);


        // 4/3 terms
        for (int i = 1; i < N - 1; i += 2) {
            double x = a + h * i;
            double fx = f.eval(x,i, params);
            if (Double.isNaN(fx)){
                System.err.println(f.getClass().getName() + "IS NaN at "+x);
            }
            sum += 4.0 * third * fx;
        }

        // 2/3 terms
        for (int i = 2; i < N - 1; i += 2) {
            double x = a + h * i;
            double fx = f.eval(x,i, params);
            if (Double.isNaN(fx)){
                System.err.println(f.getClass().getName() + "IS NaN at "+x);
            }
            sum += 2.0 * third * fx;
        }

        return sum * h;
    }

    public static double integrateConsecutive(double a, double b, int N, DoubFunction f, double ...params) {         // precision parameter
        double h = (b - a) / (N - 1);     // step size
        double fa = f.eval(a,0, params);
        if (Double.isNaN(fa) ){
            System.err.println(f.getClass().getName() + "IS NaN at "+a);
        }

        // 1/3 terms
        double sum = third*fa;


        // 4/3 terms
        boolean isOdd = true;
        for (int i = 1; i < N - 1; i += 1) {
            double x = a + h * i;
            double fx = f.eval(x,i, params);
            if (Double.isNaN(fx)){
                System.err.println(f.getClass().getName() + "IS NaN at "+x);
            }
            if (isOdd) {
                sum += 4.0 * third * fx;
            } else {
                sum += 2.0 * third * fx;
            }
            isOdd=!isOdd;
        }


        double fb = f.eval(b, N-1, params);
        if (Double.isNaN(fb)){
            System.err.println(f.getClass().getName() + "IS NaN at "+b);
        }
        sum = sum+ fb*third;

        return sum * h;
    }

    public static void main(String args[]){
        // Roots of polynumerial to integrate
        List in = Arrays.asList(-0.9, -0.8,-0.7, -0.6,-0.5, -0.4, -0.3, -0.2, -0.1, 0, .1,.2,.3,.4,.5, .6,.7, .8, .9 );
        DoubFunction func = new DoubFunction() {
            @Override
            double evalInner(double x, double[] params, int i) {
                return in.stream().map(y->y.doubleValue()-x).reduce(1.0,(a,b)->(a*b));
            }
        };
        double consec=0;
        long startConsec = System.currentTimeMillis();
        for(int i=1;i<1000; i++) {
            consec = integrateConsecutive(-1, 1, 100000, func);
        }
        double timeConsec = (System.currentTimeMillis() - startConsec)/1000.0;
        double standard=0;
        long startStandard = System.currentTimeMillis();
        for(int i=1; i<1000; i++) {
                standard = integrate(-1,1,100000,func);
        }
        double timeStandard = (System.currentTimeMillis() - startStandard)/1000.0;
        double threaded=0;
        long startThreaded = System.currentTimeMillis();
        for(int i=1;i<1000; i++) {
            threaded = integrateThreaded(-1, 1, 100000, func);
        }
        double timeThreaded = (System.currentTimeMillis() - startThreaded)/1000.0;
        System.out.println("Standard Integrator: "+standard+" time taken: "+timeStandard+" seconds");
        System.out.println("Consecutive Integrator: "+consec+" time taken: "+timeConsec+" seconds");
        System.out.println("threaded Integrator: "+threaded+" time taken: "+timeThreaded+" seconds");
    }

}

class AtomicDouble {
    private AtomicReference value = new AtomicReference(Double.valueOf(0.0));
    double getAndAdd(double delta) {
        while (true) {
            Double currentValue = value.get();
            Double newValue = Double.valueOf(currentValue.doubleValue() + delta);
            if (value.compareAndSet(currentValue, newValue))
                return currentValue.doubleValue();
        }
    }
}