Floyd Sweet VTA - Magnet Conditioning Confusion

Hey, man

Faraday's Law:
Area: 0.35 Meters (m) Squared or 35 cm squared.
Theta: 90 Degrees
B Initial: 0.0001 Tesla
B Final: 0.024 Tesla
Delta B: 2.0076 Tesla
Delta T: 0.0166666666666667 Seconds
Voltage: 120.456 Volts
Amperes: 1.7208 Amperes

Do you know of a calculator for this? The one in the reference section does not match exactly. It receives radius as input instead of area.

Anyway, this is a fantastic observation. You are paying very much attention to details. Thanks for sharing!

EDIT: Something is wrong, probably Delta B: 2.0076 Tesla . I'm very interested in being able to play with the calculator you used for this post. Thanks!

Hey CD,

I have written a class, along with many other classes to calculate this:

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///   ****************************************************************************************************************   //
///   Written by Chris Sykes                                                                                             //   
///   Copyrght 2016                                                                                                      // 
///   --> Application Name Goes Here <--                                                                                 // 
///                                                                                                                      // 
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
namespace EScience
{




    #region Using Statements:

    using System;

    #endregion




    public class FaradaysLaw
    {



        #region References:

        // See: http://farside.ph.utexas.edu/teaching/302l/lectures/node95.html

        /*

         * A plane circular loop of conducting wire of radius $r=10$cm which possesses $N=15$ turns is placed in a uniform magnetic field. 
         * The direction of the magnetic field makes an angle of $30^\circ$ with respect to the normal direction to the loop. 
         * The magnetic field-strength $B$ is increased at a constant rate from $B_1=1$T to $B_2=5$T in a time interval of  ${\mit\Delta}t=10$s.

         * What is the emf generated around the loop? 
         * If the electrical resistance of the loop is $R=15\,\Omega$, what current flows around the loop as the magnetic field is increased?
         * 
         * 
         * Answer: 

         * The area of the loop is  -  \begin{displaymath} A = \pi\,r^2 = \pi\,(0.1)^2 = 0.0314\,{\rm m}^2. \end{displaymath} 

         * The component of the magnetic field perpendicular to the loop is - \begin{displaymath} B_\perp = B\,\cos\theta = B\,\cos 30^\circ = 0.8660\,B, \end{displaymath} 

         * Where $B$ is the magnetic field-strength. 

         * Thus, the initial magnetic flux linking the loop is - \begin{displaymath} {\mit\Phi}_{B\,1} = N\,A\,B_1\,\cos\theta = (15)\,(0.0314)\,(1)\,(0.8660) = 0.408\,{\rm Wb}. \end{displaymath} 

         * Likewise, the final flux linking the loop is - \begin{displaymath} {\mit\Phi}_{B\,2} = N\,A\,B_2\,\cos\theta = (15)\,(0.0314)\,(5)\,(0.8660) = 2.039\,{\rm Wb}. \end{displaymath} 

         * The time rate of change of the flux is - \begin{displaymath} \frac{d{\mit\Phi}_B}{dt} = \frac{{\mit\Phi}_{B\,2}- {\mit\P... ...Delta}t} = \frac{(2.039-0.408)}{(10)}=0.163\,{\rm Wb\,s}^{-1}. \end{displaymath} 

         * Thus, the emf generated around the loop is - \begin{displaymath} {\cal E} = \frac{d{\mit\Phi}_B}{dt} = 0.163\,{\rm V}. \end{displaymath} 

         * Note, incidentally, that one weber per second is equivalent to one volt.

         * According to Ohm's law, the current which flows around the loop in response to the emf is - \begin{displaymath} I = \frac{{\cal E}}{R} = \frac{(0.163)}{(15)} = 0.011\,{\rm A}. \end{displaymath} 

         */

        #endregion



        #region Fields:

        // Magnetic Field B specified in the Constructor:
        private double B;


        #endregion



        #region Properties:


        /// <summary>
        /// Cross Sectional Area in Meters Squared.
        /// </summary>
        public double A
        {
            get;
            set;
        }


        /// <summary>
        /// Ohms Law can calculate the Amperes.
        /// Calculated as: I = V / R
        /// </summary>
        public double Amperes
        {
            get;
            set;
        }


        /// <summary>
        /// Initial B
        /// Calculated as: B = μNI/L
        /// </summary>
        public double BInitial
        {
            get;
            set;
        }


        /// <summary>
        /// Final B
        /// Calculated as: B = μNI/L
        /// </summary>
        public double BFinal
        {
            get;
            set;
        }


        /// <summary>
        /// Total Change in Magnetic Field B, through Area A.
        /// Calculated as: BFinal - BInitial = DeltaB
        /// </summary>
        public double DeltaB
        {
            get;
            set;
        }


        /// <summary>
        /// The Time Rate of Change of the Magnetic Flux in Seconds.
        /// </summary>
        public double DeltaT
        {
            get;
            set;
        }


        /// <summary>
        /// The Initial Magnetic Flux Linking the Loop.
        /// Calculated as: N A BInitial Cos(Theta)
        /// This Value is in Webbers.
        /// </summary>
        public double PhiB1
        {
            get;
            set;
        }


        /// <summary>
        /// The Final Magnetic Flux Linking the Loop.
        /// Calculated as: N A BFinal Cos(Theta)
        /// This Value is in Webbers.
        /// </summary>
        public double PhiB2
        {
            get;
            set;
        }


        /// <summary>
        /// The Resistance (R) of the loop of wire.
        /// </summary>
        public double R
        {
            get;
            set;
        }


        /// <summary>
        /// Theta (&theta the Angle of the Magnetic Flux.
        /// This is the Angle away from Perpendicular (90 Degrees) from the Plane of the Conductor.
        /// </summary>
        public double Theta
        {
            get;
            set;
        }


        /// <summary>
        /// The Turns of the Conductor.
        /// </summary>
        public double Turns 
        { 
            get; 
            set; 
        }


        /// <summary>
        /// Time Rate of Change of the Flux in Webbers per second.
        /// One Webber per second is equivilent to One Volt.
        /// </summary>
        public double Wbs
        {
            get;
            set;
        }


        /// <summary>
        /// The Total E.M.F (Coulombs of Charge) measured in Volts.
        /// One Webber per second is equivilent to One Volt.
        /// 1 C is equal to approximately 6.24 x 10^18, or 6.24 quintillion
        /// </summary>
        public double Volts
        {
            get;
            set;
        }



        #endregion



        /// <summary>
        /// Initialises a new instance of Faraday's Law of Electromagnetic Induction.
        /// </summary>
        /// <param name="Radius">Radius of the Circular Conductor in Centimeters</param>
        /// <param name="NumberOfTurns">The number of Turns of the Conductor</param>
        /// <param name="Theta">The Angle, Perpendicular to the Plane of the Conductor in Degrees. E.G: If the Flux is at 90 Degrees, Theta will be: 0</param>
        /// <param name="BInitial">The Initial Flux Linking the Loop, often this will be Zero in Units of Tesla</param>
        /// <param name="BFinal">The Maximum Magnetic Field in Units of Tesla</param>
        /// <param name="DeltaT">The Time Rate of Change in Seconds - Frequency or Cycles per Second</param>
        /// <param name="Resistance">The Resistance of the Conductor</param>
        public FaradaysLaw(double Radius, double NumberOfTurns, double Theta, double BInitial, double BFinal, double DeltaT, double Resistance)
        {

            CalculateArea(Radius);

            this.Turns = NumberOfTurns;
            this.Theta = Helper.DegreesToRadians(Theta);
            this.BInitial = (BInitial == 0 ? 1 : BInitial);
            this.BFinal = BFinal;
            this.DeltaT = DeltaT;
            this.B = this.BInitial;
            this.R = Resistance;


            CalculatePhiB1();

            CalculatePhiB2();

            CalculateDeltaB();

            CalculateWebbersAndVolts();

            CalculateAmperes();
        }


        /// <summary>
        /// Initialises a new instance of Faraday's Law of Electromagnetic Induction.
        /// </summary>
        /// <param name="Length">Length of the Conductor in Centimeters</param>
        /// <param name="Width">Width of the Conductor in Centimeters</param>
        /// <param name="NumberOfTurns">The number of Turns in the Conductor</param>
        /// <param name="Theta">The Angle, Perpendicular to the Plane of the Conductor in Degrees. E.G: If the Flux is at 90 Degrees, Theta will be: 0</param>
        /// <param name="BInitial">The Initial Flux Linking the Loop, often this will be Zero in Units of Tesla</param>
        /// <param name="BFinal">The Maximum Magnetic Field in Units of Tesla</param>
        /// <param name="DeltaT">The Time Rate of Change in Seconds - Frequency or Cycles per Second</param>
        /// <param name="Resistance">The Resistance of the Conductor</param>
        public FaradaysLaw(double Length, double Width, double NumberOfTurns, double Theta, double BInitial, double BFinal, double DeltaT, double Resistance)
        {

            CalculateArea(Length, Width);

            this.Turns = NumberOfTurns;
            this.Theta = Helper.DegreesToRadians(Theta);
            this.BInitial = (BInitial == 0 ? 1 : BInitial);
            this.BFinal = BFinal;
            this.DeltaT = DeltaT;
            this.B = this.BInitial;
            this.R = Resistance;


            CalculatePhiB1();

            CalculatePhiB2();

            CalculateDeltaB();

            CalculateWebbersAndVolts();

            CalculateAmperes();
        }



        /// <summary>
        /// Calculate the Area of a Circle:
        /// </summary>
        /// <param name="Radius">The Radius of the Circle.</param>
        private void CalculateArea(double Radius)
        {

            // Circumference is: 
            // C = 2 * Math.PI * Radius

            // Area of a Circle is:
            this.A = (Math.PI * Math.Pow(Radius, 2)) / 100;
        }



        /// <summary>
        /// Calculate the Area of a Rectangle, or a Square from L x W.
        /// </summary>
        /// <param name="Length">Length of the Rectangle or Square</param>
        /// <param name="Width">Width of the Rectangle or Square</param>
        private void CalculateArea(double Length, double Width)
        {
            // Length x Width is:
            this.A = (Length * Width) / 100;
        }




        /// <summary>
        /// Calculate PhiB1. This Value is in Webbers.
        /// </summary>
        private void CalculatePhiB1()
        {
            this.PhiB1 = this.Turns * this.A * this.BInitial * Math.Cos(this.Theta);
        }



        /// <summary>
        /// Calculate PhiB2. This Value is in Webbers.
        /// </summary>
        private void CalculatePhiB2()
        {
            this.PhiB2 = this.Turns * this.A * this.BFinal * Math.Cos(this.Theta);
        }



        /// <summary>
        /// Calculate DeltaB from the Constructor Input.
        /// </summary>
        private void CalculateDeltaB()
        {
            this.DeltaB = this.PhiB2 - this.PhiB1;
        }



        /// <summary>
        /// Calculate the Webbers and Volts all at once, they are the same.
        /// </summary>
        private void CalculateWebbersAndVolts()
        {

            this.Wbs = this.DeltaB / this.DeltaT;

            this.Volts = this.Wbs;
        }



        /// <summary>
        /// Calculate the Amperes that the Conductor can Supply.
        /// </summary>
        private void CalculateAmperes()
        {
            this.Amperes = this.Volts / this.R;
        }

    } // END of Class...

} // END of Namespace...

It might be Delta B might need to be checked.

Best wishes,

   Chris