/*
 * coplanar.cpp - coplanar class implementation
 *
 * Copyright (C) 2008 Michael Margraf <michael.margraf@alumni.tu-berlin.de>
 * Copyright (C) 2005, 2006 Stefan Jahn <stefan@lkcc.org>
 * Modified for Kicad: 2011 jean-pierre.charras
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this package; see the file COPYING.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
 * Boston, MA 02110-1301, USA.
 *
 */


#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>

#include "coplanar.h"
#include "units.h"

COPLANAR::COPLANAR() : TRANSLINE()
{
    m_Name    = "CoPlanar";
    backMetal = false;
    Init();
}


GROUNDEDCOPLANAR::GROUNDEDCOPLANAR() : COPLANAR()
{
    m_Name    = "GrCoPlanar";
    backMetal = true;
}


// -------------------------------------------------------------------
void COPLANAR::calcAnalyze()
{
    m_parameters[SKIN_DEPTH_PRM] = skin_depth();

    // other local variables (quasi-static constants)
    double k1, kk1, kpk1, k2, k3, q1, q2, q3 = 0, qz, er0 = 0;
    double zl_factor;

    // compute the necessary quasi-static approx. (K1, K3, er(0) and Z(0))
    k1 = m_parameters[PHYS_WIDTH_PRM]
         / ( m_parameters[PHYS_WIDTH_PRM] + m_parameters[PHYS_S_PRM] + m_parameters[PHYS_S_PRM] );
    kk1  = ellipk( k1 );
    kpk1 = ellipk( sqrt( 1 - k1 * k1 ) );
    q1   = kk1 / kpk1;


    // backside is metal
    if( backMetal )
    {
        k3 = tanh( ( M_PI / 4 ) * ( m_parameters[PHYS_WIDTH_PRM] / m_parameters[H_PRM] ) )
             / tanh( ( M_PI / 4 )
                     * ( m_parameters[PHYS_WIDTH_PRM] + m_parameters[PHYS_S_PRM]
                             + m_parameters[PHYS_S_PRM] )
                     / m_parameters[H_PRM] );
        q3        = ellipk( k3 ) / ellipk( sqrt( 1 - k3 * k3 ) );
        qz        = 1 / ( q1 + q3 );
        er0       = 1 + q3 * qz * ( m_parameters[EPSILONR_PRM] - 1 );
        zl_factor = ZF0 / 2 * qz;
    }
    // backside is air
    else
    {
        k2 = sinh( ( M_PI / 4 ) * ( m_parameters[PHYS_WIDTH_PRM] / m_parameters[H_PRM] ) )
             / sinh( ( M_PI / 4 )
                     * ( m_parameters[PHYS_WIDTH_PRM] + m_parameters[PHYS_S_PRM]
                             + m_parameters[PHYS_S_PRM] )
                     / m_parameters[H_PRM] );
        q2        = ellipk( k2 ) / ellipk( sqrt( 1 - k2 * k2 ) );
        er0       = 1 + ( m_parameters[EPSILONR_PRM] - 1 ) / 2 * q2 / q1;
        zl_factor = ZF0 / 4 / q1;
    }


    // adds effect of strip thickness
    if( m_parameters[T_PRM] > 0 )
    {
        double d, se, We, ke, qe;
        d = ( m_parameters[T_PRM] * 1.25 / M_PI )
            * ( 1 + log( 4 * M_PI * m_parameters[PHYS_WIDTH_PRM] / m_parameters[T_PRM] ) );
        se = m_parameters[PHYS_S_PRM] - d;
        We = m_parameters[PHYS_WIDTH_PRM] + d;

        // modifies k1 accordingly (k1 = ke)
        ke = We / ( We + se + se ); // ke = k1 + (1 - k1 * k1) * d / 2 / s;
        qe = ellipk( ke ) / ellipk( sqrt( 1 - ke * ke ) );

        // backside is metal
        if( backMetal )
        {
            qz        = 1 / ( qe + q3 );
            er0       = 1 + q3 * qz * ( m_parameters[EPSILONR_PRM] - 1 );
            zl_factor = ZF0 / 2 * qz;
        }
        // backside is air
        else
        {
            zl_factor = ZF0 / 4 / qe;
        }

        // modifies er0 as well
        er0 = er0
              - ( 0.7 * ( er0 - 1 ) * m_parameters[T_PRM] / m_parameters[PHYS_S_PRM] )
                        / ( q1 + ( 0.7 * m_parameters[T_PRM] / m_parameters[PHYS_S_PRM] ) );
    }

    // pre-compute square roots
    double sr_er  = sqrt( m_parameters[EPSILONR_PRM] );
    double sr_er0 = sqrt( er0 );

    // cut-off frequency of the TE0 mode
    double fte = ( C0 / 4 ) / ( m_parameters[H_PRM] * sqrt( m_parameters[EPSILONR_PRM] - 1 ) );

    // dispersion factor G
    double p = log( m_parameters[PHYS_WIDTH_PRM] / m_parameters[H_PRM] );
    double u = 0.54 - ( 0.64 - 0.015 * p ) * p;
    double v = 0.43 - ( 0.86 - 0.54 * p ) * p;
    double G = exp( u * log( m_parameters[PHYS_WIDTH_PRM] / m_parameters[PHYS_S_PRM] ) + v );

    // loss constant factors (computed only once for efficiency's sake)
    double ac = 0;
    if( m_parameters[T_PRM] > 0 )
    {
        // equations by GHIONE
        double n = ( 1 - k1 ) * 8 * M_PI / ( m_parameters[T_PRM] * ( 1 + k1 ) );
        double a = m_parameters[PHYS_WIDTH_PRM] / 2;
        double b = a + m_parameters[PHYS_S_PRM];
        ac       = ( M_PI + log( n * a ) ) / a + ( M_PI + log( n * b ) ) / b;
    }
    double ac_factor = ac / ( 4 * ZF0 * kk1 * kpk1 * ( 1 - k1 * k1 ) );
    double ad_factor = ( m_parameters[EPSILONR_PRM] / ( m_parameters[EPSILONR_PRM] - 1 ) )
                       * m_parameters[TAND_PRM] * M_PI / C0;


    // ....................................................
    double sr_er_f = sr_er0;

    // add the dispersive effects to er0
    sr_er_f += ( sr_er - sr_er0 ) / ( 1 + G * pow( m_parameters[FREQUENCY_PRM] / fte, -1.8 ) );

    // for now, the loss are limited to strip losses (no radiation
    // losses yet) losses in neper/length
    m_parameters[LOSS_CONDUCTOR_PRM] =
            20.0 / log( 10.0 ) * m_parameters[PHYS_LEN_PRM] * ac_factor * sr_er0
            * sqrt( M_PI * MU0 * m_parameters[FREQUENCY_PRM] / m_parameters[SIGMA_PRM] );
    m_parameters[LOSS_DIELECTRIC_PRM] = 20.0 / log( 10.0 ) * m_parameters[PHYS_LEN_PRM] * ad_factor
                                        * m_parameters[FREQUENCY_PRM] * ( sr_er_f * sr_er_f - 1 )
                                        / sr_er_f;

    m_parameters[ANG_L_PRM] = 2.0 * M_PI * m_parameters[PHYS_LEN_PRM] * sr_er_f
                              * m_parameters[FREQUENCY_PRM] / C0; /* in radians */

    m_parameters[EPSILON_EFF_PRM] = sr_er_f * sr_er_f;
    m_parameters[Z0_PRM]          = zl_factor / sr_er_f;
}


// -------------------------------------------------------------------
void COPLANAR::show_results()
{

    setResult( 0, m_parameters[EPSILON_EFF_PRM], "" );
    setResult( 1, m_parameters[LOSS_CONDUCTOR_PRM], "dB" );
    setResult( 2, m_parameters[LOSS_DIELECTRIC_PRM], "dB" );

    setResult( 3, m_parameters[SKIN_DEPTH_PRM] / UNIT_MICRON, "µm" );
}


#define MAX_ERROR 0.000001

// -------------------------------------------------------------------
/* @function calcSynthesize
 *
 * @TODO Add a warning in case the synthetizin algorithm did not converge.
 * Add it for all transmission lines that uses @ref minimizeZ0Error1D .
 */
void COPLANAR::calcSynthesize()
{
    if( isSelected( PHYS_WIDTH_PRM ) )
    {
        minimizeZ0Error1D( &( m_parameters[PHYS_WIDTH_PRM] ) );
    }
    else
    {
        minimizeZ0Error1D( &( m_parameters[PHYS_S_PRM] ) );
    }
}

// -------------------------------------------------------------------
void COPLANAR::showSynthesize()
{
    if( isSelected( PHYS_WIDTH_PRM ) )
        setProperty( PHYS_WIDTH_PRM, m_parameters[PHYS_WIDTH_PRM] );

    if( isSelected( PHYS_S_PRM ) )
        setProperty( PHYS_S_PRM, m_parameters[PHYS_S_PRM] );

    setProperty( PHYS_LEN_PRM, m_parameters[PHYS_LEN_PRM] );

    if( !std::isfinite( m_parameters[PHYS_S_PRM] ) || m_parameters[PHYS_S_PRM] <= 0 )
    {
        if( isSelected( PHYS_S_PRM ) )
            setErrorLevel( PHYS_S_PRM, TRANSLINE_ERROR );
        else
            setErrorLevel( PHYS_S_PRM, TRANSLINE_WARNING );
    }
    if( !std::isfinite( m_parameters[PHYS_WIDTH_PRM] ) || m_parameters[PHYS_WIDTH_PRM] <= 0 )
    {
        if( isSelected( PHYS_WIDTH_PRM ) )
            setErrorLevel( PHYS_WIDTH_PRM, TRANSLINE_ERROR );
        else
            setErrorLevel( PHYS_WIDTH_PRM, TRANSLINE_WARNING );
    }
    if( !std::isfinite( m_parameters[PHYS_LEN_PRM] ) || m_parameters[PHYS_LEN_PRM] < 0 )
        setErrorLevel( PHYS_LEN_PRM, TRANSLINE_ERROR );

    if( !std::isfinite( m_parameters[Z0_PRM] ) || m_parameters[Z0_PRM] < 0 )
        setErrorLevel( Z0_PRM, TRANSLINE_WARNING );

    if( !std::isfinite( m_parameters[ANG_L_PRM] ) || m_parameters[ANG_L_PRM] < 0 )
        setErrorLevel( ANG_L_PRM, TRANSLINE_WARNING );
}


void COPLANAR::showAnalyze()
{
    setProperty( Z0_PRM, m_parameters[Z0_PRM] );
    setProperty( ANG_L_PRM, m_parameters[ANG_L_PRM] );

    if( !std::isfinite( m_parameters[PHYS_S_PRM] ) || m_parameters[PHYS_S_PRM] <= 0 )
        setErrorLevel( PHYS_S_PRM, TRANSLINE_WARNING );

    if( !std::isfinite( m_parameters[PHYS_WIDTH_PRM] ) || m_parameters[PHYS_WIDTH_PRM] <= 0 )
        setErrorLevel( PHYS_WIDTH_PRM, TRANSLINE_WARNING );

    if( !std::isfinite( m_parameters[PHYS_LEN_PRM] ) || m_parameters[PHYS_LEN_PRM] < 0 )
        setErrorLevel( PHYS_LEN_PRM, TRANSLINE_WARNING );

    if( !std::isfinite( m_parameters[Z0_PRM] ) || m_parameters[Z0_PRM] < 0 )
        setErrorLevel( Z0_PRM, TRANSLINE_ERROR );

    if( !std::isfinite( m_parameters[ANG_L_PRM] ) || m_parameters[ANG_L_PRM] < 0 )
        setErrorLevel( ANG_L_PRM, TRANSLINE_ERROR );
}
