rt-wdf.h

Go to the documentation of this file.

/*
 ==============================================================================

 This file is part of the RT-WDF library.
 Copyright (c) 2015,2016 - Maximilian Rest, Ross Dunkel, Kurt Werner.

 Permission is granted to use this software under the terms of either:
 a) the GPL v2 (or any later version)
 b) the Affero GPL v3

 Details of these licenses can be found at: www.gnu.org/licenses

 RT-WDF 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.
 -----------------------------------------------------------------------------
 To release a closed-source product which uses RT-WDF, commercial licenses are
 available: write to rt-wdf@e-rm.de for more information.

 ==============================================================================

 rt-wdf.h
 Created: 26 Oct 2015 11:00:00am
 Author:  mrest

 ==============================================================================
 */

#ifndef __RTWDF_H__
#define __RTWDF_H__

//==============================================================================
#include <memory>



//==============================================================================
// include nlSolverClass for nonlinear solvers
#include "rt-wdf_types.h"
#include "rt-wdf_nlSolvers.h"


//==============================================================================
// Forward declarations

// WDF TREE
class wdfTree;

// ROOTS:
class wdfRoot;
    class wdfRootRtype;
    class wdfRootNL;
    class wdfRootSimple;

// UTILITIES:
class wdfPort;

// WDF TREE ELEMENTS
class wdfTreeNode;
    class wdfTerminatedAdapter;
        class wdfTerminatedRtype;
        class wdfTerminatedSeries;
        class wdfTerminatedParallel;
        class wdfInverter;
    class wdfTerminatedLeaf;
        class wdfTerminatedCap;
        class wdfTerminatedInd;
        class wdfTerminatedRes;
        class wdfTerminatedResVSource;

// WDF ROOT ELEMENTS
class wdfRootNode;
    class wdfUnterminatedSwitch;
    class wdfUnterminatedCap;
    class wdfUnterminatedInd;
    class wdfUnterminatedRes;
    class wdfIdealVSource;
    class wdfIdealCSource;


#pragma mark - Tree
//==============================================================================
//                                  T R E E
//==============================================================================
class wdfTree {

protected:
    //----------------------------------------------------------------------
    wdfTree( );

    //----------------------------------------------------------------------
    virtual ~wdfTree( );

    //----------------------------------------------------------------------
    std::unique_ptr<wdfRoot> root;

    //----------------------------------------------------------------------
    wdfTreeNode **subtreeEntryNodes;

    //----------------------------------------------------------------------
    std::unique_ptr<vec> ascendingWaves;

    //----------------------------------------------------------------------
    std::unique_ptr<vec> descendingWaves;

    //----------------------------------------------------------------------
    double treeSampleRate;

    //----------------------------------------------------------------------
    double T;

    //----------------------------------------------------------------------
    size_t subtreeCount;

    //----------------------------------------------------------------------
    double *Rp;

    //----------------------------------------------------------------------
    std::vector<paramData> params;

public:
    //----------------------------------------------------------------------
    void initTree( );

    //----------------------------------------------------------------------
    void setSamplerate( double fs );

    //----------------------------------------------------------------------
    double getSamplerate( );

    //----------------------------------------------------------------------
    int adaptTree( );

    //----------------------------------------------------------------------
    virtual int setRootMatrData( matData* rootMatrixData,
                                 double *Rp ) = 0;

    //----------------------------------------------------------------------
    void cycleWave( );

    //----------------------------------------------------------------------
    virtual void setInputValue( double signalIn ) = 0;

    //----------------------------------------------------------------------
    virtual double getOutputValue( ) = 0;

    //----------------------------------------------------------------------
    virtual const char* getTreeIdentifier( ) = 0;

    //----------------------------------------------------------------------
    const std::vector<paramData>& getParams( );

    //----------------------------------------------------------------------
    virtual void setParam( size_t paramID,
                           double paramValue ) = 0;

};

#pragma mark - Roots
//==============================================================================
//                                 R O O T S
//==============================================================================
class wdfRoot {

public:
    //----------------------------------------------------------------------
    wdfRoot( );

    //----------------------------------------------------------------------
    virtual ~wdfRoot( );

    //----------------------------------------------------------------------
    void setPortResistances( double * Rp );

    //----------------------------------------------------------------------
    virtual void processAscendingWaves( vec* ascendingWaves,
                                        vec* descendingWaves ) = 0;

    //----------------------------------------------------------------------
    virtual matData* getRootMatrPtr( );

    //----------------------------------------------------------------------
    virtual std::string getType( ) const = 0;

};

//==============================================================================
class wdfRootRtype : public wdfRoot {

private:
    //----------------------------------------------------------------------
    std::unique_ptr<matData> rootMatrixData;

    //----------------------------------------------------------------------
    int numSubtrees;

public:
    //----------------------------------------------------------------------
    wdfRootRtype( int numSubtrees );

    //----------------------------------------------------------------------
    ~wdfRootRtype( );

    //----------------------------------------------------------------------
    virtual void processAscendingWaves( vec* ascendingWaves,
                                        vec* descendingWaves );

    //----------------------------------------------------------------------
    virtual matData* getRootMatrPtr( );

    //----------------------------------------------------------------------
    virtual std::string getType( ) const;

};



//==============================================================================
class wdfRootNL : public wdfRoot {

private:
    //----------------------------------------------------------------------
    std::unique_ptr<matData> rootMatrixData;

    //----------------------------------------------------------------------
    int numSubtrees;

    //----------------------------------------------------------------------
    std::unique_ptr<nlNewtonSolver> NlSolver;

public:
    //----------------------------------------------------------------------
    wdfRootNL( int numSubtrees,
               std::vector<int> nlList,
               int solverType );

    //----------------------------------------------------------------------
    ~wdfRootNL( );

    //----------------------------------------------------------------------
    virtual void processAscendingWaves( vec* ascendingWaves,
                                        vec* descendingWaves );

    //----------------------------------------------------------------------
    virtual matData* getRootMatrPtr( );

    //----------------------------------------------------------------------
    virtual std::string getType( ) const;

};



//==============================================================================
class wdfRootSimple : public wdfRoot {

private:
    //----------------------------------------------------------------------
    std::unique_ptr<wdfRootNode> rootElement;

public:
    //----------------------------------------------------------------------
    wdfRootSimple ( wdfRootNode* rootElement );

    //----------------------------------------------------------------------
    void setPortResistances(double * Rp);

    //----------------------------------------------------------------------
    virtual void processAscendingWaves( vec* ascendingWaves,
                                        vec* descendingWaves );

    //----------------------------------------------------------------------
    virtual std::string getType( ) const ;

};

# pragma mark - Basic Tree Classes
//==============================================================================
//                                  P O R T
//==============================================================================
class wdfPort {

public:
    //----------------------------------------------------------------------
    wdfPort( wdfTreeNode* connectedNode );

    //----------------------------------------------------------------------
    double getPortVoltage( );

    //----------------------------------------------------------------------
    double getPortCurrent( );

    //----------------------------------------------------------------------
    double Rp;

    //----------------------------------------------------------------------
    double Gp;

    //----------------------------------------------------------------------
    double a;

    //----------------------------------------------------------------------
    double b;

    //----------------------------------------------------------------------
    std::unique_ptr<wdfTreeNode> connectedNode;

};


//==============================================================================
//                             T R E E   N O D E
//==============================================================================
class wdfTreeNode {

public:
    //----------------------------------------------------------------------
    wdfTreeNode( std::vector<wdfTreeNode*> childrenIn );

    wdfTreeNode( wdfTreeNode *left,
                 wdfTreeNode *right );

    wdfTreeNode( );

    //----------------------------------------------------------------------
    virtual ~wdfTreeNode( );

    //----------------------------------------------------------------------
    void setParentInChildren( );

    //----------------------------------------------------------------------
    void createPorts( );

    //----------------------------------------------------------------------
    double adaptPorts( double T );

    //----------------------------------------------------------------------
    virtual double calculateUpRes( double T ) = 0;

    //----------------------------------------------------------------------
    virtual void calculateScatterCoeffs( ) = 0;

    //----------------------------------------------------------------------
    virtual double pullWaveUp( );

    //----------------------------------------------------------------------
    virtual double calculateUpB( ) = 0;

    //----------------------------------------------------------------------
    virtual void pushWaveDown( double descendingWave );

    //----------------------------------------------------------------------
    virtual void calculateDownB( double descendingWave ) = 0;

    //----------------------------------------------------------------------
    virtual std::string getType( ) const = 0;

    //----------------------------------------------------------------------
    std::unique_ptr<wdfPort> upPort;

    //----------------------------------------------------------------------
    std::unique_ptr<wdfTreeNode> parentNode;

protected:
    //----------------------------------------------------------------------
    std::vector<wdfPort*> downPorts;

    //----------------------------------------------------------------------
    std::vector<wdfTreeNode*> childrenNodes;

};

#pragma mark - Terminated Adapters
//==============================================================================
//              T E R M I N A T E D   A D A P T E R S   (S, P, R)
//==============================================================================
class wdfTerminatedAdapter: public wdfTreeNode {

public:
    //----------------------------------------------------------------------
    wdfTerminatedAdapter( wdfTreeNode *left,
                          wdfTreeNode *right );
    wdfTerminatedAdapter( std::vector<wdfTreeNode*> childrenIn );

    //----------------------------------------------------------------------
    ~wdfTerminatedAdapter( );

};

//==============================================================================
class wdfTerminatedRtype: public wdfTerminatedAdapter {

public:
    //----------------------------------------------------------------------
    wdfTerminatedRtype( std::vector<wdfTreeNode*> childrenIn );

    //----------------------------------------------------------------------
    ~wdfTerminatedRtype();

    //----------------------------------------------------------------------
    virtual double calculateUpRes( double T ) = 0;

    //----------------------------------------------------------------------
    virtual void calculateScatterCoeffs( ) = 0;

    //----------------------------------------------------------------------
    virtual double calculateUpB( );

    //----------------------------------------------------------------------
    virtual void calculateDownB( double descendingWave );

    //----------------------------------------------------------------------
    virtual std::string getType( ) const;

protected:
    //----------------------------------------------------------------------
    std::unique_ptr<mat> S;

};

//==============================================================================
class wdfTerminatedSeries : public wdfTerminatedAdapter {

private:
    //----------------------------------------------------------------------
    double yu;
    double yl;
    double yr;

public:
    //----------------------------------------------------------------------
    wdfTerminatedSeries( wdfTreeNode *left,
                         wdfTreeNode *right );

    //----------------------------------------------------------------------
    virtual double calculateUpRes( double T );

    //----------------------------------------------------------------------
    virtual void calculateScatterCoeffs( );

    //----------------------------------------------------------------------
    virtual double calculateUpB( );

    //----------------------------------------------------------------------
    virtual void calculateDownB( double descendingWave );

    //----------------------------------------------------------------------
    virtual std::string getType( ) const;

};

//==============================================================================
class wdfTerminatedParallel : public wdfTerminatedAdapter {

private:
    //----------------------------------------------------------------------
    double du;
    double dl;
    double dr;

public:
    //----------------------------------------------------------------------
    wdfTerminatedParallel( wdfTreeNode *left,
                           wdfTreeNode *right );

    //----------------------------------------------------------------------
    virtual double calculateUpRes( double T );

    //----------------------------------------------------------------------
    virtual void calculateScatterCoeffs( );

    //----------------------------------------------------------------------
    virtual double calculateUpB();

    //----------------------------------------------------------------------
    virtual void calculateDownB( double descendingWave );

    //----------------------------------------------------------------------
    virtual std::string getType( ) const;

};

class wdfInverter : public wdfTerminatedAdapter {

public:
    //----------------------------------------------------------------------
    wdfInverter( wdfTreeNode *child );

    //----------------------------------------------------------------------
    virtual double calculateUpRes( double T );

    //----------------------------------------------------------------------
    virtual void calculateScatterCoeffs( );

    //----------------------------------------------------------------------
    virtual double calculateUpB( );

    //----------------------------------------------------------------------
    virtual void calculateDownB( double descendingWave );

    //----------------------------------------------------------------------
    virtual std::string getType( ) const;

};

#pragma mark - Terminated Leafs
//==============================================================================
//                    T E R M I N A T E D   L E A F S   (Q)
//==============================================================================
class wdfTerminatedLeaf: public wdfTreeNode {

public:
    //----------------------------------------------------------------------
    wdfTerminatedLeaf();

    //----------------------------------------------------------------------
    virtual void calculateScatterCoeffs( );

};

//==============================================================================
class wdfTerminatedCap : public wdfTerminatedLeaf {

public:
    //----------------------------------------------------------------------
    wdfTerminatedCap( double C,
                      double T );

    //----------------------------------------------------------------------
    virtual double calculateUpRes( double T );

    //----------------------------------------------------------------------
    virtual double calculateUpB( );

    //----------------------------------------------------------------------
    virtual void calculateDownB( double descendingWave );

    //----------------------------------------------------------------------
    virtual std::string getType( ) const;

    //----------------------------------------------------------------------
    double C;
    double T;
    double prevA;

};

//==============================================================================
class wdfTerminatedInd : public wdfTerminatedLeaf {

public:
    //----------------------------------------------------------------------
    wdfTerminatedInd( double L,
                      double T );

    //----------------------------------------------------------------------
    virtual double calculateUpRes( double T );

    //----------------------------------------------------------------------
    virtual double calculateUpB( );

    //----------------------------------------------------------------------
    virtual void calculateDownB( double descendingWave );

    //----------------------------------------------------------------------
    virtual std::string getType( ) const;

    //----------------------------------------------------------------------
    double L;
    double T;
    double prevA;

};

//==============================================================================
class wdfTerminatedRes : public wdfTerminatedLeaf {

public:
    //----------------------------------------------------------------------
    wdfTerminatedRes( double R );

    //----------------------------------------------------------------------
    virtual double calculateUpRes( double T );

    //----------------------------------------------------------------------
    virtual double calculateUpB( );

    //----------------------------------------------------------------------
    virtual void calculateDownB( double descendingWave );

    //----------------------------------------------------------------------
    virtual std::string getType( ) const;

    //----------------------------------------------------------------------
    double R;

};

//==============================================================================
class wdfTerminatedResVSource : public wdfTerminatedLeaf {

public:
    //----------------------------------------------------------------------
    wdfTerminatedResVSource( double Vs,
                             double RSer );

    //----------------------------------------------------------------------
    virtual double calculateUpRes( double T );

    //----------------------------------------------------------------------
    virtual double calculateUpB( );

    //----------------------------------------------------------------------
    virtual void calculateDownB( double descendingWave );

    //----------------------------------------------------------------------
    virtual std::string getType( ) const;

    //----------------------------------------------------------------------
    double Vs;
    double RSer;

};

#pragma mark - Root Nodes
//==============================================================================
//                             R O O T   N O D E
//==============================================================================
class wdfRootNode {

protected:
    //----------------------------------------------------------------------
    double Rp;
    size_t numPorts;

public:
    //----------------------------------------------------------------------
    wdfRootNode( int numPorts );

    //----------------------------------------------------------------------
    virtual ~wdfRootNode( );

    //----------------------------------------------------------------------
    virtual void setPortResistance( double Rp );

    //----------------------------------------------------------------------
    virtual void calculateDownB( vec* ascendingWaves,
                                 vec* descendingWaves,
                                 size_t* portIndex ) = 0;

    //----------------------------------------------------------------------
    int getNumPorts( );

    //----------------------------------------------------------------------
    virtual std::string getType( ) const = 0;

};


//==============================================================================
//                  U N T E R M I N A T E D   E L E M E N T S
//==============================================================================
class wdfUnterminatedSwitch : public wdfRootNode {

private:
    //----------------------------------------------------------------------
    int position;

public:
    //----------------------------------------------------------------------
    wdfUnterminatedSwitch( int position );

    //----------------------------------------------------------------------
    virtual void calculateDownB( vec* ascendingWaves,
                                 vec* descendingWaves,
                                 size_t* portIndex );

    //----------------------------------------------------------------------
    void setSwitch( int position );

    //----------------------------------------------------------------------
    virtual std::string getType( ) const;

};

#pragma mark - Unterminated Leafs
//==============================================================================
class wdfUnterminatedCap : public wdfRootNode {

protected:
    //----------------------------------------------------------------------
    double T;
    double prevA;
    double prevB;
    double reflectionCoeff;

public:
    //----------------------------------------------------------------------
    wdfUnterminatedCap( double C,
                        double T );

    //----------------------------------------------------------------------
    virtual void calculateDownB( vec* ascendingWaves,
                                 vec* descendingWaves,
                                 size_t* portIndex );

    //----------------------------------------------------------------------
    void setPortResistance( double Rp );

    //----------------------------------------------------------------------
    virtual std::string getType( ) const;

    //----------------------------------------------------------------------
    double C;

};

//==============================================================================
class wdfUnterminatedInd : public wdfRootNode {

protected:
    //----------------------------------------------------------------------
    double T;
    double prevA;
    double prevB;
    double reflectionCoeff;

public:
    //----------------------------------------------------------------------
    wdfUnterminatedInd( double L,
                        double T );

    //----------------------------------------------------------------------
    virtual void calculateDownB( vec* ascendingWaves,
                                 vec* descendingWaves,
                                 size_t* portIndex );

    //----------------------------------------------------------------------
    void setPortResistance( double Rp );

    //----------------------------------------------------------------------
    virtual std::string getType( ) const;

    //----------------------------------------------------------------------
    double L;

};

//==============================================================================
class wdfUnterminatedRes: public wdfRootNode {

protected:
    //----------------------------------------------------------------------
    double reflectionCoeff;

public:
    //----------------------------------------------------------------------
    wdfUnterminatedRes( double R );

    //----------------------------------------------------------------------
    virtual void calculateDownB( vec* ascendingWaves,
                                 vec* descendingWaves,
                                 size_t* portIndex );

    //----------------------------------------------------------------------
    void setPortResistance( double Rp );

    //----------------------------------------------------------------------
    virtual std::string getType( ) const;

    //----------------------------------------------------------------------
    double R;

};

//==============================================================================
class wdfIdealVSource: public wdfRootNode {

public:
    //----------------------------------------------------------------------
    wdfIdealVSource( double Vs );

    //----------------------------------------------------------------------
    virtual void calculateDownB( vec* ascendingWaves,
                                 vec* descendingWaves,
                                 size_t* portIndex );

    //----------------------------------------------------------------------
    void setPortResistance( double Rp );

    //----------------------------------------------------------------------
    virtual std::string getType( ) const;

    //----------------------------------------------------------------------
    double Vs;

};

//==============================================================================
class wdfIdealCSource: public wdfRootNode {

public:
    //----------------------------------------------------------------------
    wdfIdealCSource(double I_in);

    //----------------------------------------------------------------------
    virtual void calculateDownB( vec* ascendingWaves,
                                 vec* descendingWaves,
                                 size_t* portIndex );

    //----------------------------------------------------------------------
    void setPortResistance( double Rp );

    //----------------------------------------------------------------------
    virtual std::string getType( ) const;

    //----------------------------------------------------------------------
    double Is;

};

#endif  // RTWDF_H_INCLUDED