AMSKernel.hh

Go to the documentation of this file.

#ifndef AMSKERNEL_HH
#define AMSKERNEL_HH

// Copyright (c) 2002-2005 The University of Cincinnati.  All rights
// reserved.

// You may modify, distribute, and use the software contained in this
// package under the terms of the "GNU LIBRARY GENERAL PUBLIC LICENSE"
// version 2, June 1991. A copy of this license agreement can be found in
// the file "LGPL", distributed with this archive.

// Authors: Sameer Kher                    kherss@ececs.uc.edu
//          Shriram Subramanian            subramsi@ececs.uc.edu

#include <math.h>
#include <list>
#include "tyvis/VHDLKernel.hh"
#include "tyvis/NodeList.hh"
#include "tyvis/Constants.hh"
#include "tyvis/ContributionNode.hh"
#include "tyvis/AMSKernel_state.hh"
extern "C" {
#include "spmatrix.h"
}

using std::list;

class component;
class Quantity;

class AMSKernel: public VHDLKernel {

public:
  AMSKernel();
  virtual ~AMSKernel();
  
  /* Returns the pointer to the current set of equations in the analog
     process for the present time point. */
  list<component *> *getCurrentEquations() ;
  
  int matrixLoad(char *matrix);
      
  int iterate(int MaxIter, char *matrix);
      
  int getAnalysis() {
    return analysis;
  }
  
  int getMatrixSize() const;
  
  char* getDcMatrix();

  char* getTransientMatrix();

  int addNode(int nodeId, nodeConstants type);
  
  int addNodeCond(int nodeId, nodeConstants type);
  
  int addNodeCond(int nodeId, nodeConstants type,char* nam);
      
  int findNodeRHS(int nodeId);   
  
  void formCurrentEquations();

  void checkSolvability();
      
  void initialSettingUp();
  
  component* getComp() const;
  
  list<Quantity *>* getSetOfQuantities(); 
  
  void completeDynamicState();
  
  void definePointersAcross();
      
  void newSetBranch();
  
  int findDCOp(long firstMode, int iterLimit);
   
  virtual void setup(void)=0;   
  
  int newLoad(char *matrix);

  int newPointerAllocation();
  
  int newCheckCurrent(int posNode, int negNode, int indexVal);
  
  double* getRhs();
      
  double* getOldRhs();
      
  int newFindBranch(int posNode, int negNode);
      
  inline nodeList* getRhsNodes() const;
  
  void executeVHDL() {
    executeAnalogVHDL();
  }
  
  int executeAnalogVHDL() {  
    initialSettingUp();
    return 1;
  }
  
  void add(component* newcomp);
  
  virtual void printFunction() = 0;
      
  int getFreeLoadEqnCounter();
  
  void incrementFreeLoadEqnCounter();

  discreteTime getCurTime() ;

  int trunc(double *timeStep);

  void truncError(int qcap, double* timeStep);

  void updateQuantityValues(); 

  double getNewIterValueOfQuantity(Quantity *quantityPtr);

  double getPrevIterValueOfQuantity(Quantity *);

  int simulate(discreteTime endTime);

  double* getStateVector(int i);

  void createStates(); 

  int getStateLength();

  void incrementState();

  void copyStates(int from, int to);

  void rotateStates();

  int integrate(double* matrixValue,double* rhsValue, int stateIndex);

  long getMode();

  int compCoeff();

protected:
  
  AMSKernel_state *getSolverState(){ return (AMSKernel_state *)getState(); }

private:

  double pivotAbsTol;

  double pivotRelTol;

  nodeList* rhsNodes;
  
  char* dcMatrix;

  char* transientMatrix;

  enum {DC,TRANSIENT} analysis;

  int dcMaxIter;

  int transientMaxIter;

  component* comp;

  int noConv;

  int freeLoadEqnCounter;

  list<component *> *currentEquations;

  list<Quantity *> *setOfQuantities;

  int convergenceTest();

  double maxStep;
  
  double delMin;

  discreteTime startTime;

  bool setupFlag;

  int maxIntegOrder;

  double voltTol;

  double absTol;

  double relTol;

  double chgTol;

  double trTol;


};
#endif

---