Beispiel #1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="X"></param>
        /// <param name="P"></param>
        /// <param name="Y"></param>
        /// <remarks>
        /// P[0]: M_0,
        /// P[1]: M_infinity
        /// P[2]: tau_relax
        /// P[3]: beta
        /// P[4]: invviscosity
        /// </remarks>
        public void Evaluate(double[] X, double[] P, double[] Y)
        {
            double x = X[0];

            if (_useFrequencyInsteadOmega)
            {
                x *= (2 * Math.PI);
            }

            double w_r = x * P[2]; // omega scaled with tau

            Complex result = P[1] + (P[0] - P[1]) * Kohlrausch.ReIm(P[3], w_r);

            if (_useFlowTerm)
            {
                result = 1 / ((1 / result) - Complex.I * P[4] / x);
            }

            if (_logarithmizeResults)
            {
                Y[0] = Math.Log10(result.Re);
                Y[1] = Math.Log10(result.Im);
            }
            else
            {
                Y[0] = result.Re;
                Y[1] = result.Im;
            }
        }
Beispiel #2
0
        public void Evaluate(double[] X, double[] P, double[] Y)
        {
            double x = X[0];

            if (_useFrequencyInsteadOmega)
            {
                x *= (2 * Math.PI);
            }

            double w_r = x * P[2]; // omega scaled with tau

            Complex result = P[0] + P[1] * Kohlrausch.ReIm(P[3], w_r);

            Y[0] = result.Re;

            if (this._useFlowTerm)
            {
                if (this._isDielectricData)
                {
                    Y[1] = -result.Im + P[4] / (x * 8.854187817e-12);
                }
                else
                {
                    Y[1] = -result.Im + P[4] / (x);
                }
            }
            else
            {
                Y[1] = -result.Im;
            }
        }
Beispiel #3
0
        public void Evaluate(double[] X, double[] P, double[] Y)
        {
            double x = X[0];

            if (_useFrequencyInsteadOmega)
            {
                x *= (2 * Math.PI);
            }

            Complex result = P[0];

            int iPar = 1;
            int i;

            for (i = 0, iPar = 1; i < _numberOfRelaxations; i++, iPar += 3)
            {
                result += P[0 + iPar] * Kohlrausch.ReIm(P[2 + iPar], P[1 + iPar] * x);
            }

            // note: because it is a susceptiblity, the imaginary part is still negative

            if (_useFlowTerm)
            {
                if (_isDielectricData)
                {
                    result.Im -= P[iPar] / (x * 8.854187817e-12);
                }
                else if (_invertViscosity)
                {
                    result.Im -= P[iPar] / (x);
                }
                else
                {
                    result.Im -= 1 / (P[iPar] * x);
                }
            }

            if (_invertResult)
            {
                result = 1 / result; // if we invert, i.e. we calculate the modulus, the imaginary part is now positive
            }
            else
            {
                result.Im = -result.Im; // else if we don't invert, i.e. we calculate susceptibility, we negate the imaginary part to make it positive
            }
            if (_logarithmizeResults)
            {
                result.Re = Math.Log10(result.Re);
                result.Im = Math.Log10(result.Im);
            }

            Y[0] = result.Re;
            Y[1] = result.Im;
        }
        public void Evaluate(double[] X, double[] P, double[] Y)
        {
            double x = X[0];

            if (_useFrequencyInsteadOmega)
            {
                x *= (2 * Math.PI);
            }

            double w_r = x * P[2]; // omega scaled with tau

            Complex result = 1 / P[1] + (1 / P[0] - 1 / P[1]) * Kohlrausch.ReIm(P[3], w_r);

            if (this._useFlowTerm)
            {
                result.Im -= P[4] / (x);
            }


            result = 1 / result;
            Y[0]   = result.Re;
            Y[1]   = result.Im;
        }
Beispiel #5
0
 public void TestRe2()
 {
     double result = Kohlrausch.Re(0.03125, Math.Exp(-5 / 0.03125));
 }
Beispiel #6
0
 public void TestRe1()
 {
     double result = Kohlrausch.Re1(0.5, 1024);
 }
Beispiel #7
0
 public void TestIm2SmallBeta()
 {
     double beta   = 1 / 32.0;
     double result = Kohlrausch.Im2SmallBeta(beta, Math.Exp(-5 / beta));
 }
Beispiel #8
0
 public void TestIm2()
 {
     double beta   = 63 / 32.0;
     double result = Kohlrausch.Im2(beta, Math.Exp(2.65625 / beta));
 }
Beispiel #9
0
 public void TestIm1()
 {
     double result = Kohlrausch.Im1(1.0 + 4 / 32.0, 1);
 }