コード例 #1
0
        private void AddLeptons()
        {
            // ADD ELECTRON
            Electron e = new Electron();

            particles.Add(e);
            // ADD MUON
            Muon muon = new Muon();

            particles.Add(muon);
            // ADD TAUON
            Tauon tau = new Tauon();

            particles.Add(tau);

            // ADD ELECTRON NEUTRINO
            ElectronNeutrino nu_e = new ElectronNeutrino();

            particles.Add(nu_e);
            // ADD MUON NEUTRINO
            MuonNeutrino nu_muon = new MuonNeutrino();

            particles.Add(nu_muon);
            // ADD TAUON NEUTRINO
            TauonNeutrino nu_tau = new TauonNeutrino();

            particles.Add(nu_tau);
        }
コード例 #2
0
    public void UntrackElectron(Electron electron)
    {
        unanalyzedElectrons.Remove(electron);
        analyzedElectrons.Remove(electron);

        AnalyzeElectrons();
    }
コード例 #3
0
ファイル: Program.cs プロジェクト: punker76/Electron.NET
        public static async Task Main(string[] args)
        {
            IWebHostBuilder builder;

#if DEBUG
            var webPort = Electron.Experimental.FreeTcpPort();

            await Electron.Experimental.StartElectronForDevelopment(webPort);

            builder = CreateWebHostBuilder(args);
            // check for the content folder if its exists in base director otherwise no need to include
            // It was used before because we are publishing the project which copies everything to bin folder and contentroot wwwroot was folder there.
            // now we have implemented the live reload if app is run using /watch then we need to use the default project path.
            if (Directory.Exists($"{AppDomain.CurrentDomain.BaseDirectory}\\wwwroot"))
            {
                builder.UseContentRoot(AppDomain.CurrentDomain.BaseDirectory);
            }

            builder.UseUrls("http://localhost:" + webPort);
#else
            builder = CreateWebHostBuilder(args);
            Debugger.Launch();
            Electron.ReadAuth();
            builder.UseElectron(args);
#endif

            await builder.Build().RunAsync();
        }
コード例 #4
0
        public void Verify_Entangled_Electrons_Maintain_Entanglement()
        {
            Electron one = new Electron();
            Electron two = new Electron();

            int count_diff = 0;
            int count_all  = 0;

            // measure them both on the X axis
            for (int i = 0; i < 1000; ++i)
            {
                one.Randomize();
                two.EntangleSpins(one);

                // measure them both on the X axis - a bunch of times!
                for (int j = 0; j < 1000; ++j)
                {
                    ++count_all;
                    if (one.Spin(SPIN_AXIS.SPIN_AXIS_X) != two.Spin(SPIN_AXIS.SPIN_AXIS_X))
                    {
                        ++count_diff;
                    }
                }
            }
            // measure them both on the Y axis
            for (int i = 0; i < 1000; ++i)
            {
                one.Randomize();
                two.EntangleSpins(one);

                // measure them both on the Y axis - a bunch of times!
                for (int j = 0; j < 1000; ++j)
                {
                    ++count_all;
                    if (one.Spin(SPIN_AXIS.SPIN_AXIS_Y) != two.Spin(SPIN_AXIS.SPIN_AXIS_Y))
                    {
                        ++count_diff;
                    }
                }
            }
            // measure them both on the Z axis
            for (int i = 0; i < 1000; ++i)
            {
                one.Randomize();
                two.EntangleSpins(one);

                // measure them both on the Z axis - a bunch of times!
                for (int j = 0; j < 1000; ++j)
                {
                    ++count_all;
                    if (one.Spin(SPIN_AXIS.SPIN_AXIS_Z) != two.Spin(SPIN_AXIS.SPIN_AXIS_Z))
                    {
                        ++count_diff;
                    }
                }
            }

            Assert.True(count_diff == count_all, "Must allways be anti-correlated.");
        }
コード例 #5
0
        /// <summary>
        /// Populates the <see cref="Orbital"/> with an electron.
        /// </summary>
        public void Populate()
        {
            if (this[0] == null)
            {
                this[0] = new Electron(ElectronSpin.Up);
                return;
            }

            this[1] = new Electron(ElectronSpin.Down);
        }
コード例 #6
0
    //As electron is spawned, analyze its projectile data and give it a call-back to update analysis if it bounces
    public void TrackElectron(Electron electron)
    {
        if (!unanalyzedElectrons.Contains(electron))
        {
            unanalyzedElectrons.Add(electron);
        }

        electron.SetBounceCallback(UpdateTrackedElectron);

        AnalyzeElectrons();
    }
コード例 #7
0
        public void Verify_Entangled_Electrons_Decohere()
        {
            Electron one = new Electron();
            Electron two = new Electron();

            int count_diff = 0;
            int count_all  = 0;

            // measure them both on the X axis
            for (int i = 0; i < 1000; ++i)
            {
                one.Randomize();
                two.EntangleSpins(one);

                ++count_all;
                bool measure_once = one.Spin(SPIN_AXIS.SPIN_AXIS_Z) != two.Spin(SPIN_AXIS.SPIN_AXIS_Z);
                // measurement on Z should break entanglement on X
                if (one.Spin(SPIN_AXIS.SPIN_AXIS_X) != two.Spin(SPIN_AXIS.SPIN_AXIS_X))
                {
                    ++count_diff;
                }
            }
            // measure them both on the Y axis
            for (int i = 0; i < 1000; ++i)
            {
                one.Randomize();
                two.EntangleSpins(one);

                ++count_all;
                bool measure_once = one.Spin(SPIN_AXIS.SPIN_AXIS_X) != two.Spin(SPIN_AXIS.SPIN_AXIS_X);
                // measurement on X should break entanglement on Y
                if (one.Spin(SPIN_AXIS.SPIN_AXIS_Y) != two.Spin(SPIN_AXIS.SPIN_AXIS_Y))
                {
                    ++count_diff;
                }
            }
            // measure them both on the Z axis
            for (int i = 0; i < 1000; ++i)
            {
                one.Randomize();
                two.EntangleSpins(one);

                ++count_all;
                bool measure_once = one.Spin(SPIN_AXIS.SPIN_AXIS_Y) != two.Spin(SPIN_AXIS.SPIN_AXIS_Y);
                // measurement on Y should break entanglement on Z
                if (one.Spin(SPIN_AXIS.SPIN_AXIS_Z) != two.Spin(SPIN_AXIS.SPIN_AXIS_Z))
                {
                    ++count_diff;
                }
            }

            Assert.False(count_diff == count_all, "Must not always be anti-correlated.");
        }
コード例 #8
0
    public void UpdateTrackedElectron(Electron electron)
    {
        //When an electron bounces, its projectile data is now useless and we should recalculate it

        analyzedElectrons.Remove(electron);
        if (!unanalyzedElectrons.Contains(electron))
        {
            unanalyzedElectrons.Add(electron);
        }

        AnalyzeElectrons();
    }
コード例 #9
0
    void SpawnElectron(int index)
    {
        GameObject elecObj = GameObject.Instantiate(electronTemp);

        elecObj.transform.parent        = electronContainer.transform;
        elecObj.transform.localPosition = Vector3.zero;
        Electron electron = elecObj.GetComponent <Electron> ();

        ElectronData data = CalculateElectronData(index);

        electron.SetElectronLocation(data.position);
        electron.SetRotation(sphere.transform.position, data.normal, speed);
        elecObj.SetActive(true);
    }
コード例 #10
0
    public void generateElectron(Vector3 pos, float r, int shell)
    {
        GameObject electron = (GameObject)Instantiate(Resources.Load("Electron"));

        electron.name = "Electron";
        electron.transform.localScale = new Vector3(0.01f, 0.01f, 0.01f);
        electron.transform.position   = pos;
        electron.transform.parent     = GameObject.Find("Shell " + shell).transform;
        GameObject.Destroy(electron.GetComponent <SphereCollider>());
        Electron e = electron.AddComponent <Electron>();

        e.radius        = r;
        e.centre        = transform;
        e.rotationSpeed = 8 + (10 * shell);
    }
コード例 #11
0
    //TODO: the Launcher shouldn't own the logic to bind the Bot's tracking to the individual Electrons
    //this may be better done in whatever manager takes care of pooling the Electrons
    //all of the pooled Electrons could be given the callback once at scene start

    public void FireElectron(Vector3 firingForce)
    {
        GameObject elecObj = Instantiate <GameObject>(electronPrefab, electronParent, true);

        elecObj.name = "Electron " + id++;
        elecObj.transform.position = electronSpawn.position;

        Rigidbody elecRB = elecObj.GetComponent <Rigidbody>();

        elecRB.velocity = firingForce;
        //elecRB.AddForce(firingForce);

        Electron electron = elecObj.GetComponent <Electron>();

        UpdateBotTracking(electron);
    }
コード例 #12
0
        public void Verify_Randomized_Electrons_Not_Entangled()
        {
            Electron one = new Electron();
            Electron two = new Electron();

            int count_diff = 0; // we count anti-correlation
            int count_all  = 0;

            // measure them both on the X axis
            for (int i = 0; i < 1000; ++i)
            {
                one.Randomize();
                two.Randomize();

                ++count_all;
                if (one.Spin(SPIN_AXIS.SPIN_AXIS_X) != two.Spin(SPIN_AXIS.SPIN_AXIS_X))
                {
                    ++count_diff;
                }
            }
            // measure them both on the Y axis
            for (int i = 0; i < 1000; ++i)
            {
                one.Randomize();
                two.Randomize();

                ++count_all;
                if (one.Spin(SPIN_AXIS.SPIN_AXIS_Y) != two.Spin(SPIN_AXIS.SPIN_AXIS_Y))
                {
                    ++count_diff;
                }
            }
            // measure them both on the Z axis
            for (int i = 0; i < 1000; ++i)
            {
                one.Randomize();
                two.Randomize();

                ++count_all;
                if (one.Spin(SPIN_AXIS.SPIN_AXIS_Z) != two.Spin(SPIN_AXIS.SPIN_AXIS_Z))
                {
                    ++count_diff;
                }
            }

            Assert.False(count_diff == count_all, "Should not all be anti-correlated.");
        }
コード例 #13
0
ファイル: Atom.cs プロジェクト: markusstrasser/atomFlight
    void MakeOrbits(int electrons, int orbitCount)
    {
        int elRest = electrons;

        for (int i = 0; i <= orbitCount; i++)
        {
            GameObject orbit = new GameObject();
            orbit.name                    = "Orbit" + i;
            orbit.transform.parent        = transform;
            orbit.transform.localPosition = Vector3.zero;

            CircleLine myRing = Instantiate <CircleLine>(ring);
            myRing.SetOrbitCapacity(elAndO[i, 0]);
            myRing.SetElectronCount(elAndO[i, 1]);


            myRing.CreatePoints(orbitRadius * (i + 1));
            myRing.transform.parent        = transform;
            myRing.transform.localPosition = Vector3.zero;

            //Shell for Orbit
            GameObject Shell = Instantiate <GameObject>(pulseObj);
            Shell.transform.parent        = orbit.transform;
            Shell.transform.localPosition = Vector3.zero;
            float sr = (i + 1) * orbitRadius * 2f;

            Shell.transform.localScale = new Vector3(sr, sr, sr);
            //Electrons
            for (int j = 0; j < orbitThreshold[i]; j++)
            {
                Electron ele = Instantiate <Electron>(myElectron);
                ele.transform.parent = orbit.transform;
                float partinCircle = (float)j / orbitThreshold[i];
                ele.Arrange(i, orbitRadius, partinCircle);

                elRest--;
                if (elRest <= 0)
                {
                    return;
                }
            }
        }
    }
コード例 #14
0
    void Start()
    {
        Camera camera = Camera.main;
        limitX = camera.orthographicSize * camera.aspect;
        limitY = camera.orthographicSize;

        for (int i = 0; i < count; ++i)
        {
            Electron electron = new Electron();
            electron.gameObject = Instantiate<GameObject>(prefab);
            electron.gameObject.transform.SetParent(transform, false);
            electrons.Add(electron);

            electron.position = new Vector2(
                (Random.value - 0.5f) * 2f * limitX,
                (Random.value - 0.5f) * 2f * limitY
            );
        }
	}
コード例 #15
0
    public void FireElectron()
    {
        GameObject elecObj = Instantiate <GameObject>(electronPrefab, electronParent, true);

        elecObj.name = "Electron " + id++;
        elecObj.transform.position = electronSpawn.position;

        Vector3 randomForce = new Vector3(
            Random.Range(minFiringForce.x, maxFiringForce.x),
            Random.Range(minFiringForce.y, maxFiringForce.y),
            0);
        Rigidbody elecRB = elecObj.GetComponent <Rigidbody>();

        elecRB.velocity = randomForce;
        //elecRB.AddForce(randomForce);

        Electron electron = elecObj.GetComponent <Electron>();

        UpdateBotTracking(electron);
    }
コード例 #16
0
    private ProjectileTrajectoryData AnalyzeTarget(Electron proj, Vector3 currentCatcherPosition)
    {
        //Calculate an electron's landing time and position based on its velocity
        //Store this in ProjectileTrajectoryData so we don't have to recalculate anything until a collision occurs

        float timeToGround;

        if (proj.rb.velocity.y > 0)
        {
            float timeToRise = proj.rb.velocity.y / -Physics.gravity.y;
            float maxHeight  = proj.transform.position.y + proj.rb.velocity.y * timeToRise - (0.5f * -Physics.gravity.y * Mathf.Pow(timeToRise, 2));
            float timeToFall = Mathf.Sqrt((2f * (maxHeight - landingPlaneHeight)) / -Physics.gravity.y);
            timeToGround = timeToRise + timeToFall;
            //Debug.Log("Upward projectile analysis for " + proj.gameObject.name + ": timeToGround = " + timeToGround +
            //", maxHeight = " + maxHeight + ", timeToFall = " + timeToFall);
        }
        else
        {
            timeToGround = (-proj.rb.velocity.y - Mathf.Sqrt(Mathf.Abs(Mathf.Pow(proj.rb.velocity.y, 2) - (2f * Physics.gravity.y * -(landingPlaneHeight - proj.transform.position.y))))) / Physics.gravity.y;
            //Debug.Log("Falling projectile analysis for " + proj.gameObject.name + ": timeToGround = " + timeToGround +
            //", y0 = " + proj.transform.position.y + ", Vy0 = " + proj.rb.velocity.y);
        }

        Vector3 landingLocation = new Vector3(
            proj.rb.velocity.x * timeToGround + proj.rb.position.x,
            landingPlaneHeight,
            proj.rb.velocity.z * timeToGround + proj.rb.position.z);

        float distance    = Vector3.Distance(landingLocation, currentCatcherPosition);
        float timeToCatch = distance / moveSpeed;

        ProjectileTrajectoryData projectileData = new ProjectileTrajectoryData();

        projectileData.landingTimestamp = timeToGround + Time.time;
        projectileData.landingLocation  = landingLocation;
        projectileData.catchable        = IsCatchable(projectileData, currentCatcherPosition);

        return(projectileData);
    }
コード例 #17
0
        /// <summary> Helper method to calculate correlation on chosen axes. </summary>
        /// <param name="A"> The spin axis for Alice. </param>
        /// <param name="B"> The spin axis for Bob. </param>
        /// <param name="count"> The optional number of tests to run. Default 1000. </param>
        public static double CorrelateElectronsOnAxes(SPIN_AXIS A, SPIN_AXIS B, int count = 1000)
        {
            Electron one = new Electron();
            Electron two = new Electron();

            double count_same = 0.0;
            double count_diff = 0.0;
            double count_all  = 0.0;

            for (int i = 0; i < count; ++i)
            {
                one.Randomize();
                two.EntangleSpins(one);

                int isA = one.Spin(A);
                int isB = two.Spin(B);

                count_all += 1.0;
                if (isA == isB)
                {
                    count_same += 1.0;
                }
                else
                {
                    count_diff += 1.0;
                }
            }

            // sadly, I forget where I saw this equation for calculating the correlation.
            //  usually it is more like:
            //
            //    C = (num_pp + num_mm - num_pm - num_mp) / (num_pp + num_mm + num_pm + num_mp)
            //
            //  but this is arithmetically equivalent. ( when strictly using real numbers. )
            //
            return((count_same - count_diff) / count_all);
        }
コード例 #18
0
 private void UpdateBotTracking(Electron electron)
 {
     bot.TrackElectron(electron);
     electron.SetDisableCallback(bot.UntrackElectron);
 }
コード例 #19
0
        /// <summary>
        /// Run the three axes Bell Inequality Test against Sinnable Electrons.
        /// </summary>
        /// <remarks>
        /// See https://en.wikipedia.org/wiki/Sakurai%27s_Bell_inequality
        /// </remarks>
        internal static void BellTriAxisElectronSpinTest()
        {
            SPIN_AXIS[] filters =
            {
                SPIN_AXIS.SPIN_AXIS_X,
                SPIN_AXIS.SPIN_AXIS_Y,
                SPIN_AXIS.SPIN_AXIS_Z
            };
            // every test works with two photons.
            Electron one = new Electron();
            Electron two = new Electron();
            // various counts of the tests that pass the spin question.
            int count_same    = 0;
            int count_same_XY = 0;
            int count_same_YZ = 0;
            int count_same_ZX = 0;
            int count_all     = 0;
            int count_all_XY  = 0;
            int count_all_YZ  = 0;
            int count_all_ZX  = 0;

            for (int i = 0; i < 1000; ++i)
            {
                // force them to pick different filters
                //  X + Y, Y + Z, Z + X
                int       index_A = (i + 0) % 3;
                int       index_B = (i + 1) % 3;
                SPIN_AXIS A       = filters[index_A];
                SPIN_AXIS B       = filters[index_B];

                // each test starts with a randomized particle
                one.Randomize();
                // and a particle in _perfect_ entanglement with it.
                two.EntangleSpins(one);

                int answer_A = one.Spin(A);
                int answer_B = two.Spin(B);
                count_all++;
                // so we can know how many on each filter.
                switch (index_A)
                {
                case 0: ++count_all_XY; break;

                case 1: ++count_all_YZ; break;

                case 2: ++count_all_ZX; break;
                }
                // count when they are in agreement.
                if (answer_A == answer_B)
                {
                    ++count_same;
                    // and again, on each filter.
                    switch (index_A)
                    {
                    case 0: ++count_same_XY; break;

                    case 1: ++count_same_YZ; break;

                    case 2: ++count_same_ZX; break;
                    }
                }
            }
            // correlation regardless of axes choice
            double CE = (2.0 * count_same - count_all) / count_all;
            // correlation on specific axes choice
            double Cxy = (2.0 * count_same_XY - count_all_XY) / count_all_XY;
            double Cyz = (2.0 * count_same_YZ - count_all_YZ) / count_all_YZ;
            double Czx = (2.0 * count_same_ZX - count_all_ZX) / count_all_ZX;
            // estimate of correlation combined.
            double Ch     = Cxy - Cyz - Czx;
            bool   spooky = (Ch >= 1.0);

            Console.WriteLine(String.Format("Ce={0} Ch={1}, from {2} == {3}",
                                            CE, Ch, count_all,
                                            spooky ? "Spooky" : "Classic"));
        }
コード例 #20
0
 public Orbital(IOrbitalGroup of)
 {
     Of       = of ?? throw new ArgumentNullException(nameof(of));
     SpinUp   = new Electron();
     SpinDown = new Electron();
 }
コード例 #21
0
 public void Spawn()
 {
     randomLocation = Random.Range(0, 9);
     electron       = Instantiate(electronPrefab, spawnLocation[randomLocation], Quaternion.identity) as Electron;
 }
コード例 #22
0
ファイル: Form1.cs プロジェクト: xuchuansheng/GenXSource
        private void AddLeptons()
        {
            // ADD ELECTRON
            Electron e = new Electron();
            particles.Add(e);
            // ADD MUON
            Muon muon = new Muon();
            particles.Add(muon);
            // ADD TAUON
            Tauon tau = new Tauon();
            particles.Add(tau);

            // ADD ELECTRON NEUTRINO
            ElectronNeutrino nu_e = new ElectronNeutrino();
            particles.Add(nu_e);
            // ADD MUON NEUTRINO
            MuonNeutrino nu_muon = new MuonNeutrino();
            particles.Add(nu_muon);
            // ADD TAUON NEUTRINO
            TauonNeutrino nu_tau = new TauonNeutrino();
            particles.Add(nu_tau);
        }