patch.tgz

src/0000777000175000017500000000000013653617203007743 5ustar  dkcdkcsrc/DeviceModelPKG/0000777000175000017500000000000013653617203012465 5ustar  dkcdkcsrc/DeviceModelPKG/Core/0000777000175000017500000000000013660205157013354 5ustar  dkcdkcsrc/DeviceModelPKG/Core/N_DEV_BridgeOp.inc0000666000175000017500000000013513654372532016521 0ustar  dkcdkc// Enum list for code bridge operations

BRIDGE_OP(Init)
BRIDGE_OP(Update)

#undef BRIDGE_OP
src/DeviceModelPKG/Core/N_DEV_DeviceEntity.C0000666000175000017500000020567113654372532017047 0ustar  dkcdkc//-------------------------------------------------------------------------
//   Copyright 2002-2020 National Technology & Engineering Solutions of
//   Sandia, LLC (NTESS).  Under the terms of Contract DE-NA0003525 with
//   NTESS, the U.S. Government retains certain rights in this software.
//
//   This file is part of the Xyce(TM) Parallel Electrical Simulator.
//
//   Xyce(TM) 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 3 of the License, or
//   (at your option) any later version.
//
//   Xyce(TM) 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 Xyce(TM).
//   If not, see <http://www.gnu.org/licenses/>.
//-------------------------------------------------------------------------

//-------------------------------------------------------------------------
//
// Purpose        :
//
// Special Notes  :
//
// Creator        : Eric R. Keiter, SNL, Parallel Computational Sciences
//
// Creation Date  : 04/03/00
//
//
//
//
//-------------------------------------------------------------------------

#include <Xyce_config.h>

#include <string>
#include <iostream>
#if defined(HAVE_UNORDERED_MAP)
#include <unordered_map>
using std::unordered_map;
#elif defined(HAVE_TR1_UNORDERED_MAP)
#include <tr1/unordered_map>
using std::tr1::unordered_map;
#else
#error neither unordered_map or tr1/unordered_map found
#endif
#include <N_DEV_fwd.h>
#include <N_DEV_CompositeParam.h>
#include <N_DEV_Const.h>
#include <N_DEV_DeviceEntity.h>
#include <N_DEV_DeviceOptions.h>
#include <N_DEV_Message.h>
#include <N_DEV_Param.h>
#include <N_DEV_SolverState.h>
#include <N_LAS_Vector.h>
#include <N_UTL_BreakPoint.h>
#include <N_UTL_Diagnostic.h>
#include <N_UTL_Expression.h>
#include <N_UTL_FeatureTest.h>

namespace Xyce {
namespace Device {

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::DeviceEntity
// Purpose       : constructor
// Special Notes :
// Scope         : public
// Creator       : Dave Shirley, PSSI
// Creation Date : 12/13/04
//-----------------------------------------------------------------------------
DeviceEntity::DeviceEntity(
  ParametricData<void> &        parametric_data,
  const SolverState &           solver_state,
  const DeviceOptions &         device_options,
  const NetlistLocation &       netlist_location)
  : defaultParamName_(),
    parametricData_(parametric_data),
    netlistLocation_(netlist_location),
    solState_(solver_state),
    globals_(solver_state.getGlobals()),
    devOptions_(device_options)
{}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::~DeviceEntity
// Purpose       : destructor
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 3/30/00
//-----------------------------------------------------------------------------
DeviceEntity::~DeviceEntity()
{
  for (std::vector<Depend>::iterator d = dependentParams_.begin(), end = dependentParams_.end(); d != end; ++d)
  {
    delete d->expr;
  }
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::scaleParam
//
// Purpose : Scales the original value of the specified parameter by the specified value.
// The parameter is never specified by the user so errors are developer caused.
//
// Special Notes :
//
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 02/21/04
//-----------------------------------------------------------------------------
bool DeviceEntity::scaleParam( const std::string & paramName, double val, double val0)
{
  ParameterMap::const_iterator p_i = getParameterMap().find(paramName);
  if (p_i == getParameterMap().end())
  {
    DevelFatal(*this).in("DeviceEntity::scaleParam") << "Unrecognized parameter " << paramName;
    return false;
  }

  const Descriptor &param = *(*p_i).second;
  if (!param.hasOriginalValueStored())
  {
    DevelFatal(*this).in("DeviceEntity::scaleParam") << "Original value not available for parameter " << paramName;
    return false;
  }

  if (!param.isType<double>())
  {
    DevelFatal(*this).in("DeviceEntity::scaleParam") << "Can scale only double parameters, parameter " << paramName << " is not double";
    return false;
  }

  // Scale the parameter
  setValue<double, DeviceEntity>(*this, param, Xyce::Device::getOriginalValue(*this, param.getSerialNumber())*val + val0*(1.0-val));

  if (param.hasGivenMember())
    param.setGiven(*this, true);

  Xyce::Device::setValueGiven(*this, param.getSerialNumber(), true);

  return true;
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::scaleParam
//
// Purpose       : Scales the specified parameter by a specified value.
// The parameter is never specified by the user so errors are developer caused.
//
// Special Notes :
//
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 02/21/04
//-----------------------------------------------------------------------------
bool DeviceEntity::scaleParam( const std::string & paramName, double val)
{
  ParameterMap::const_iterator p_i = getParameterMap().find(paramName);
  if (p_i == getParameterMap().end())
  {
    DevelFatal(*this).in("DeviceEntity::scaleParam") << "Unrecognized parameter " << paramName;
    return false;
  }

  const Descriptor &param = *(*p_i).second;
  if (!param.hasOriginalValueStored())
  {
    DevelFatal(*this).in("DeviceEntity::scaleParam") << "Original value not available for parameter " << paramName;
    return false;
  }

  if (!param.isType<double>())
  {
    DevelFatal(*this).in("DeviceEntity::scaleParam") << "Can scale only double parameters, parameter " << paramName << " is not double";
    return false;
  }

  // Scale the parameter
  param.value<double>(*this) = Xyce::Device::getOriginalValue(*this, param.getSerialNumber())*val;

  if (param.hasGivenMember())
    param.setGiven(*this, true);

  Xyce::Device::setValueGiven(*this, param.getSerialNumber(), true);

  return true;
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::scaleDefaultParam
// Purpose       :
// The parameter is never specified by the user so errors are developer caused.
// Special Notes :
// Scope         : public
// Creator       : Robert Hoekstra, SNL, Parallel Computational Sciences
// Creation Date : 5/19/05
//-----------------------------------------------------------------------------
bool DeviceEntity::scaleDefaultParam(double val)
{
  if (defaultParamName_.empty())
  {
    DevelFatal(*this).in("DeviceEntity::scaleDefaultParam") << "Device does not have a default parameter";
    return false;
  }

  return scaleParam(defaultParamName_, val);
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::analyticSensitivityAvailable
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL
// Creation Date : 7/17/2014
//-----------------------------------------------------------------------------
bool DeviceEntity::analyticSensitivityAvailable (const std::string & paramName)
{
  ParameterMap::const_iterator p_i = getParameterMap().find(paramName);
  if (p_i == getParameterMap().end())
  {
    DevelFatal(*this).in("DeviceEntity::analyticSensitivityAvailable") << "Unrecognized parameter " << paramName;
    return false;
  }

  const Descriptor &param = *(*p_i).second;
  return param.getAnalyticSensitivityAvailable();
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::analyticSensitivityAvailableDefaultParam
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL
// Creation Date : 8/16/2015
//-----------------------------------------------------------------------------
bool DeviceEntity::analyticSensitivityAvailableDefaultParam ()
{
  if (defaultParamName_.empty())
  {
    DevelFatal(*this).in("DeviceEntity::analyticSensitivityAvailableDefaultParam") 
      << "Device does not have a default parameter";
    return false;
  }

  return analyticSensitivityAvailable(defaultParamName_);
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::getAnalyticSensitivity
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL
// Creation Date : 7/17/2014
//-----------------------------------------------------------------------------
bool DeviceEntity::getAnalyticSensitivity ( const std::string & paramName,
                                            std::vector<double> & dfdpVec,
                                            std::vector<double> & dqdpVec,
                                            std::vector<double> & dbdpVec,
                                            std::vector<int> & FindicesVec,
                                            std::vector<int> & QindicesVec,
                                            std::vector<int> & BindicesVec)
{
  ParameterMap::const_iterator p_i = getParameterMap().find(paramName);
  if (p_i == getParameterMap().end())
  {
    DevelFatal(*this).in("DeviceEntity::analyticSensitivityAvailable") << "Unrecognized parameter " << paramName;
    return false;
  }

  const Descriptor &param = *(*p_i).second;

  return param.getAnalyticSensitivity (*this, paramName, dfdpVec, dqdpVec, dbdpVec,
      FindicesVec, QindicesVec, BindicesVec);
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::getAnalyticSensitivityDefaultParam
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL
// Creation Date : 7/17/2014
//-----------------------------------------------------------------------------
bool DeviceEntity::getAnalyticSensitivityDefaultParam (
                                            std::vector<double> & dfdpVec,
                                            std::vector<double> & dqdpVec,
                                            std::vector<double> & dbdpVec,
                                            std::vector<int> & FindicesVec,
                                            std::vector<int> & QindicesVec,
                                            std::vector<int> & BindicesVec)
{
  if (defaultParamName_.empty())
  {
    DevelFatal(*this).in("DeviceEntity::getAnalyticSensitivityDefaultParam") 
      << "Device does not have a default parameter";
    return false;
  }

  return getAnalyticSensitivity(defaultParamName_,
      dfdpVec, dqdpVec, dbdpVec, FindicesVec, QindicesVec, BindicesVec);
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::getNumericalSensitivityDefaultParam
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL
// Creation Date : 
//-----------------------------------------------------------------------------
bool DeviceEntity::getNumericalSensitivityDefaultParam (
                                            std::vector<double> & dfdpVec,
                                            std::vector<double> & dqdpVec,
                                            std::vector<double> & dbdpVec,
                                            std::vector<int> & FindicesVec,
                                            std::vector<int> & QindicesVec,
                                            std::vector<int> & BindicesVec)
{
  if (defaultParamName_.empty())
  {
    DevelFatal(*this).in("DeviceEntity::getNumericalSensitivityDefaultParam") 
      << "Device does not have a default parameter";
    return false;
  }

  return getNumericalSensitivity(defaultParamName_,
      dfdpVec, dqdpVec, dbdpVec, FindicesVec, QindicesVec, BindicesVec);
}

//

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::analyticMatrixSensitivityAvailable
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL
// Creation Date : 7/17/2014
//-----------------------------------------------------------------------------
bool DeviceEntity::analyticMatrixSensitivityAvailable (const std::string & paramName)
{
  ParameterMap::const_iterator p_i = getParameterMap().find(paramName);
  if (p_i == getParameterMap().end())
  {
    DevelFatal(*this).in("DeviceEntity::analyticMatrixSensitivityAvailable") << "Unrecognized parameter " << paramName;
    return false;
  }

  const Descriptor &param = *(*p_i).second;
  return param.getAnalyticMatrixSensitivityAvailable();
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::analyticMatrixSensitivityAvailableDefaultParam
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL
// Creation Date : 8/16/2015
//-----------------------------------------------------------------------------
bool DeviceEntity::analyticMatrixSensitivityAvailableDefaultParam ()
{
  if (defaultParamName_.empty())
  {
    DevelFatal(*this).in("DeviceEntity::analyticMatrixSensitivityAvailableDefaultParam") 
      << "Device does not have a default parameter";
    return false;
  }

  return analyticMatrixSensitivityAvailable(defaultParamName_);
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::getAnalyticMatrixSensitivity
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL
// Creation Date : 7/17/2014
//-----------------------------------------------------------------------------
bool DeviceEntity::getAnalyticMatrixSensitivity ( const std::string & paramName,
    std::vector <std::vector<double> > & d_dfdx_dp,
    std::vector <std::vector<double> > & d_dqdx_dp,
    std::vector<int> & F_lids,
    std::vector<int> & Q_lids,
    std::vector< std::vector<int> > & F_jacLIDs,
    std::vector< std::vector<int> > & Q_jacLIDs )
{
  ParameterMap::const_iterator p_i = getParameterMap().find(paramName);
  if (p_i == getParameterMap().end())
  {
    DevelFatal(*this).in("DeviceEntity::analyticMatrixSensitivityAvailable") << "Unrecognized parameter " << paramName;
    return false;
  }

  const Descriptor &param = *(*p_i).second;

  return param.getAnalyticMatrixSensitivity (*this, paramName, 
    d_dfdx_dp, d_dqdx_dp, F_lids, Q_lids, F_jacLIDs, Q_jacLIDs);
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::getAnalyticMatrixSensitivityDefaultParam
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL
// Creation Date : 7/17/2014
//-----------------------------------------------------------------------------
bool DeviceEntity::getAnalyticMatrixSensitivityDefaultParam (
    std::vector <std::vector<double> > & d_dfdx_dp,
    std::vector <std::vector<double> > & d_dqdx_dp,
    std::vector<int> & F_lids,
    std::vector<int> & Q_lids,
    std::vector< std::vector<int> > & F_jacLIDs,
    std::vector< std::vector<int> > & Q_jacLIDs )
{
  if (defaultParamName_.empty())
  {
    DevelFatal(*this).in("DeviceEntity::getAnalyticMatrixSensitivityDefaultParam") 
      << "Device does not have a default parameter";
    return false;
  }

  return getAnalyticMatrixSensitivity(defaultParamName_,
    d_dfdx_dp, d_dqdx_dp, F_lids, Q_lids, F_jacLIDs, Q_jacLIDs);
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::getNumericalMatrixSensitivityDefaultParam
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL
// Creation Date : 
//-----------------------------------------------------------------------------
bool DeviceEntity::getNumericalMatrixSensitivityDefaultParam (
    std::vector <std::vector<double> > & d_dfdx_dp,
    std::vector <std::vector<double> > & d_dqdx_dp,
    std::vector<int> & F_lids,
    std::vector<int> & Q_lids,
    std::vector< std::vector<int> > & F_jacLIDs,
    std::vector< std::vector<int> > & Q_jacLIDs )
{
  if (defaultParamName_.empty())
  {
    DevelFatal(*this).in("DeviceEntity::getNumericalMatrixSensitivityDefaultParam") 
      << "Device does not have a default parameter";
    return false;
  }

  DevelFatal(*this).in("DeviceEntity::getNumericalMatrixSensitivity") 
      << "Function not implemented yet ";
  return false;

  return getNumericalMatrixSensitivity(defaultParamName_,
    d_dfdx_dp, d_dqdx_dp, F_lids, Q_lids, F_jacLIDs, Q_jacLIDs);
}
//
//-----------------------------------------------------------------------------
// Function      : DeviceEntity::getAnalyticACSensitivityAvailable 
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL
// Creation Date : 4/2/2019
//-----------------------------------------------------------------------------
bool DeviceEntity::getAnalyticACSensitivityAvailable (const std::string & paramName)
{
  ParameterMap::const_iterator p_i = getParameterMap().find(paramName);
  if (p_i == getParameterMap().end())
  {
    DevelFatal(*this).in("DeviceEntity::getAnalyticACSensitivityAvailable") << "Unrecognized parameter " << paramName;
    return false;
  }

  const Descriptor &param = *(*p_i).second;
  return param.getAnalyticACSensitivityAvailable ();
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::getAnalyticACSensitivityAvailableDefaultParam
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL
// Creation Date : 4/2/2019
//-----------------------------------------------------------------------------
bool DeviceEntity::getAnalyticACSensitivityAvailableDefaultParam ()
{
  if (defaultParamName_.empty())
  {
    DevelFatal(*this).in("DeviceEntity::getAnalyticACSensitivityAvailableDefaultParam") 
      << "Device does not have a default parameter";
    return false;
  }

  return getAnalyticACSensitivityAvailable(defaultParamName_);
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::getAnalyticBSensVectorsforAC
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL
// Creation Date : 4/2/2019
//-----------------------------------------------------------------------------
bool DeviceEntity::getAnalyticBSensVectorsforAC (const std::string & paramName,
          std::vector< std::complex<double> > & dbdp,
          std::vector<int> &        BindicesVec)
{
  ParameterMap::const_iterator p_i = getParameterMap().find(paramName);
  if (p_i == getParameterMap().end())
  {
    DevelFatal(*this).in("DeviceEntity::analyticSensitivityAvailable") << "Unrecognized parameter " << paramName;
    return false;
  }

  const Descriptor &param = *(*p_i).second;
  return param.getAnalyticBSensVectorsforAC (*this, paramName, dbdp, BindicesVec);
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::getAnalyticBSensVectorsforACDefaultParam
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL
// Creation Date : 4/2/2019
//-----------------------------------------------------------------------------
bool DeviceEntity::getAnalyticBSensVectorsforACDefaultParam (
          std::vector< std::complex<double> > & dbdp,
          std::vector<int> &        BindicesVec)
{
  if (defaultParamName_.empty())
  {
    DevelFatal(*this).in("DeviceEntity::getAnalyticBSensVectorsforACDefaultParam") 
      << "Device does not have a default parameter";
    return false;
  }

  return getAnalyticBSensVectorsforAC(defaultParamName_, dbdp, BindicesVec);
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::getNumericalBSensVectorsforACDefaultParam
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL
// Creation Date : 4/2/2019
//-----------------------------------------------------------------------------
bool DeviceEntity::getNumericalBSensVectorsforACDefaultParam (
          std::vector< std::complex<double> > & dbdp,
          std::vector<int> &        BindicesVec)
{
  return true;
}

//

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::setParam
//
// Purpose       : This function loops over the vector of parameters, and
//                 sets the specified one (if found) to a specified value.
//
// Special Notes : This is kind of tricky, b/c some parameters are actually
//                 deep inside other classes (like a source class, for
//                 example)
//
//                 This function always returns a true, b/c there are many
//                 instances, (for example running in parallel), where one
//                 could set a param that didn't exist locally on
//                 processor.
//
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 07/25/03
//-----------------------------------------------------------------------------
bool DeviceEntity::setParam(const std::string & paramName, double val, bool overrideOriginal)
{
  //if (DEBUG_DEVICE)
  if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS))
  {
    Xyce::dout() << "DeviceEntity::setParam  with paramname = " << paramName << " value = " << val << " overrideOriginal = " << overrideOriginal << std::endl;
  }
  
  ParameterMap::const_iterator p_i = getParameterMap().find(paramName);
  if (p_i == getParameterMap().end())
    return false;


  const Descriptor &param = *(*p_i).second;

  if (isTempParam(paramName) && param.getAutoConvertTemperature())
    val += CONSTCtoK;

  if (param.isType<double>())
    param.value<double>(*this) = val;
  else if (param.isType<int>())
    param.value<int>(*this) = static_cast <int> (val);
  else if (param.isType<long>())
    param.value<long>(*this) =  static_cast <long> (val);
  else if (param.isType<bool>())
    param.value<bool>(*this) = (val != 0);
  else
    DevelFatal(*this) << "Illegal type for parameter " << paramName;

  if (param.hasGivenMember())
    param.setGiven(*this, true);

  Xyce::Device::setValueGiven(*this, param.getSerialNumber(), true);

  if (param.hasOriginalValueStored() && overrideOriginal)
  {
    //if (DEBUG_DEVICE)
    if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS))
    {
      Xyce::dout() << " Overriding original value for parameter " << paramName << "  with value " << val << std::endl;
    }
    Xyce::Device::setOriginalValue(*this,param.getSerialNumber(), val);
  }
  
  return true;
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::findParam
//
// Purpose       : returns true if parameter exists for device
//
// Scope         : public
// Creator       : David G. Baur, Raytheon
// Creation Date : 07/01/2016
//-----------------------------------------------------------------------------
bool DeviceEntity::findParam(const std::string & param_name) const
{
  return getParameterMap().find(param_name) != getParameterMap().end();
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::getParam
//
// Purpose       : returns the value of the requested param.
//
// Special Notes : This  function currently assumes that the requested
//                 param is a double-precision number.
//
//                 Parameters are not case-dependent.
//
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 07/25/03
//-----------------------------------------------------------------------------
bool DeviceEntity::getParam(const std::string & name, double & result) const
{
  double val = 0.0;
  bool found = false;

  ParameterMap::const_iterator p_i = getParameterMap().find(name);
  if (p_i != getParameterMap().end())
  {
    found = true;
    const Descriptor &param = *(*p_i).second;
    if (param.isType<double>())
      val = param.value<double>(*this);
    else if (param.isType<int>())
      val = static_cast <double> (param.value<int>(*this));
    else if (param.isType<long>())
      val = static_cast <double> (param.value<long>(*this));
    else if (param.isType<bool>())
    {
      if (param.value<bool>(*this))
        val = 1;
      else
        val = 0;
    }
    else
    {
      DevelFatal(*this).in("DeviceEntity::getParam") << "Illegal type for parameter " << name;
    }
    if (isTempParam(name)  && param.getAutoConvertTemperature())
      val -= CONSTCtoK;
  }
  else
  {
    // If not recognized, just do nothing
  }
  result = val;

  return found;
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::setDefaultParam
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 11/06/03
//-----------------------------------------------------------------------------
bool DeviceEntity::setDefaultParam (double val, bool overrideOriginal)
{
  if (defaultParamName_.empty())
  {
    DevelFatal(*this).in("DeviceEntity::setDefaultParam") << "Device does not have a default parameter";
  }

  return setParam(defaultParamName_, val, overrideOriginal);
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::getDefaultParam
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 11/06/03
//-----------------------------------------------------------------------------
double DeviceEntity::getDefaultParam() const
{
  if (defaultParamName_.empty())
  {
    return 0.0;
  }

  double result = 0.0;

  getParam(defaultParamName_, result);

  return result;
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::setDependentParameter
// Purpose       : Add expression, param pairs for future updates
// Special Notes :  This is an overloaded method, used instead of the old
//                  monolithic one.
// Scope         : protected
// Creator       : Tom Russo
// Creation Date : 6 Nov 07
//-----------------------------------------------------------------------------
///
/// Create a Depend object for a parameter, fill it in, and add to the dependParam_ vector
///
/// @param[in] par Util::Param object with name/value pair
/// @param[in] res A pointer to the member variable of the entity into which parameter values are stored
/// @param[in] depend expression access permissions for the parameter
///
/// This function is used when it is determined that a single device
/// parameter (as opposed to a parameter inside a vector composite)
/// depends (via an expression) on external quantities.
///
/// We create a Depend object and add it to the list, then call the
/// utility version of setDependentParameter to populate it
///
/// This version of setDependentParameter was split out of an older
/// "monolithic" method that was festooned with if statements to
/// perform multiple functions.  This function is now single purpose.
/// What remains of the old monolithic function is now in the
/// overloaded utility function below, also named
/// "setDependentParameter," but with different prototype.
///
/// @note The Depend objects contain an expression pointer, and are
/// copied using shallow copy.  Thus, when the local variable
/// "dependentParam" is added to the dependentParams_ vector, the
/// expression pointer is copied, not the underlying expression
/// object.  This fact is used after the push to the back of
/// dependentParams_, when the expression pointer in dependentParam is
/// used to access the expression for evaluation.  Because the pointer
/// is shared between dependentParam and the copy that has been pushed
/// back, this works.
///
/// @author Tom Russo
/// @date 11/6/2007
///
double DeviceEntity::setDependentParameter (Util::Param & par,
                                            double *res,
                                            ParameterType::ExprAccess depend)

{
  Depend dependentParam;
  setDependentParameter(par, dependentParam, depend);

  dependentParam.resultU.result = res;
  dependentParam.vectorIndex = -1;
  dependentParams_.push_back(dependentParam);

  double rval;
  dependentParam.expr->evaluateFunction (rval);
  dependentParam.expr->set_sim_time(getSolverState().currTime_);
  dependentParam.expr->set_sim_dt(getSolverState().currTimeStep_);
  dependentParam.expr->set_sim_freq(getSolverState().currFreq_);
  dependentParam.expr->set_temp(devOptions_.temp.getImmutableValue<double>());

  return rval;
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::setDependentParameter
// Purpose       : Add expression, param pairs for future updates
// Special Notes :  This is an overloaded method, used instead of the old
//                  monolithic one, and is specifically to set an element
//                  of a double vector.
// Scope         : protected
// Creator       : Tom Russo
// Creation Date : 6 Nov 07
//-----------------------------------------------------------------------------
///
/// Create a Depend object for a parameter, fill it in, and add to the dependParam_ vector
///
/// @param[in] par Util::Param object with name/value pair
/// @param[in] res A pointer to a vector of doubles, which should be a member variable of the entity, and in which the values of the parameter should be stored
/// @param[in] ind  integer index into the res vector, denoting the location in the vector where this parameter should be stored
/// @param[in] depend expression access permissions for the parameter
///
/// This function is used when it is determined that a parameter
/// inside a vector composite depends (via an expression) on external
/// quantities.
///
/// We create a Depend object and add it to the list, then call the
/// utility version of setDependentParameter to populate it
///
/// This version of setDependentParameter was split out of an older
/// "monolithic" method that was festooned with if statements to
/// perform multiple functions.  This function is now single purpose.
/// What remains of the old monolithic function is now in the
/// overloaded utility function below, also named
/// "setDependentParameter," but with different prototype.
///
/// @note The Depend objects contain an expression pointer, and are
/// copied using shallow copy.  Thus, when the local variable
/// "dependentParam" is added to the dependentParams_ vector, the
/// expression pointer is copied, not the underlying expression
/// object.  This fact is used after the push to the back of
/// dependentParams_, when the expression pointer in dependentParam is
/// used to access the expression for evaluation.  Because the pointer
/// is shared between dependentParam and the copy that has been pushed
/// back, this works.
///
/// @author Tom Russo
/// @date 11/6/2007
///
double DeviceEntity::setDependentParameter (Util::Param & par,
                                            std::vector<double> *res,
                                            int ind,
                                            ParameterType::ExprAccess depend)

{
  Depend dependentParam;
  setDependentParameter(par,dependentParam, depend);

  dependentParam.resultU.resVec = res;
  dependentParam.vectorIndex = ind;
  dependentParams_.push_back(dependentParam);

  double rval;
  dependentParam.expr->evaluateFunction (rval);
  dependentParam.expr->set_sim_time(getSolverState().currTime_);
  dependentParam.expr->set_sim_dt(getSolverState().currTimeStep_);
  dependentParam.expr->set_sim_freq(getSolverState().currFreq_);
  dependentParam.expr->set_temp(devOptions_.temp.getImmutableValue<double>());

  return rval;
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::setDependentParameter
// Purpose       : Add expression, param pairs for future updates
// Special Notes :  This is a utility version, used by overloaded methods.
// Scope         : public
// Creator       : Dave Shirley, PSSI
// Creation Date : 11/18/04
//-----------------------------------------------------------------------------
///
/// Fill in a Depend structure that establishes that a given parameter
/// is dependent on external quantities (solution variables, global parameters,
/// etc.), associates an expression with the parameter, and sets up necessary
/// information to evaluate the parameter as needed.
///
/// The DeviceEntity maintains a list of Depend structures in vector
/// dependParams_.  During simulation, this list is consulted whenever a
/// device load needs to happen, and it is used to update parameters whose
/// dependent quantities have changed.
///
/// @param[in] par  The Util::Param object with the name/value pair
/// @param dependentParam A pre-constructed Depend object to be filled in
/// @param[in] depend expression access permissions for the parameter
///
/// This function is called as a utility function by the two other
/// overloaded setDependentParameter methods.
///
/// @author Dave Shirley, PSSI
/// @date 11/18/04
///
void DeviceEntity::setDependentParameter (Util::Param & par,
                                          Depend & dependentParam,
                                          ParameterType::ExprAccess depend)
{
  std::vector<std::string> instances, leads, names, variables;

  dependentParam.name = par.tag();
  ParameterMap::const_iterator p_i = getParameterMap().find(dependentParam.name);
  const Descriptor &param = *(*p_i).second;
  if (isTempParam(par.tag()) && param.getAutoConvertTemperature())
  {
    //User input for temperature is in degrees C.  Devices use degrees K internally.
    dependentParam.expr = new Util::Expression ("(" + par.stringValue() + ")+CONSTCtoK");

    // Need to get the string names of the variables that are in par's expression,
    // and then use that vector of string names to make them variables in the
    // dependentParam's expression also.  This is needed to support global parameters
    // in expressions for the TEMP instance paramter.
    std::vector<std::string> parVars;
    par.getValue<Util::Expression>().get_names(XEXP_VARIABLE, parVars);
    for (std::vector<std::string>::const_iterator pv_i=parVars.begin(); pv_i != parVars.end(); ++pv_i)
    {
      dependentParam.expr->make_var(*pv_i);
    }

    dependentParam.expr->make_constant (std::string("CONSTCTOK"), CONSTCtoK);
  }
  else
  {
    dependentParam.expr = new Util::Expression (par.getValue<Util::Expression>());
  }

  if (param.hasOriginalValueStored())
  {
    dependentParam.storeOriginal=true;
    dependentParam.serialNumber=param.getSerialNumber();
  }
  else
  {
    dependentParam.storeOriginal=false;
  }

  names.clear();
  leads.clear();
  instances.clear();
  variables.clear();

  dependentParam.expr->get_names(XEXP_NODE, names);
  dependentParam.expr->get_names(XEXP_LEAD, leads);
  dependentParam.expr->get_names(XEXP_INSTANCE, instances);
  dependentParam.expr->get_names(XEXP_VARIABLE, variables);

  //std::vector<std::string>::iterator s;
  std::vector<std::string>::iterator iterS;

  if (!(depend & ParameterType::SOLN_DEP))
  {
    if (names.size() > 0 || instances.size() > 0)
    {
      UserError(*this) << "Parameter " << par.tag() << " is not allowed to depend on voltage/current values";
      return;
    }
    if (depend & ParameterType::NO_DEP)
    {
      if (dependentParam.expr->get_num(XEXP_SPECIAL) > 0)
      {
        UserError(*this) << "Parameter " << par.tag() << " is not allowed to depend on time";
        return;
      }
    }
  }

  if (leads.size() > 0)
  {
    char type;
    int index;
    for (std::vector<std::string>::const_iterator n_i=leads.begin(); n_i != leads.end(); ++n_i)
    {
      index = n_i->find_last_of(":");
      if (index == std::string::npos )
        type = (*n_i)[0];
      else
        type = (*n_i)[index+1];

      if (type != 'B' && type != 'E' && type != 'H')
      {
        UserError(*this) << "Illegal use of lead current specification in expression '" << dependentParam.expr->get_expression()
                         << "' in parameter " << par.tag();
      }
    }
    names.insert( names.end(), leads.begin(), leads.end() );
  }

  names.insert( names.end(), instances.begin(), instances.end() );

  dependentParam.lo_var = expVarNames.size();
  dependentParam.n_vars = names.size();
  dependentParam.vals.resize(dependentParam.n_vars);
  int expVarLen = dependentParam.lo_var+dependentParam.n_vars;
  expVarGIDs.resize(expVarLen);
  expVarLIDs.resize(expVarLen);
  expVarVals.resize(expVarLen);

  if (!variables.empty())
    names.insert( names.end(), variables.begin(), variables.end() );

  if ( !names.empty() )
  {
    // Order the names in the expression so that it agrees with the order
    // in names.
    dependentParam.expr->order_names( names );
  }
  for (int i=0 ; i<dependentParam.n_vars ; ++i)
    expVarNames.push_back(names[i]);

  if (dependentParam.n_vars > 0)
  {
    std::vector<double> zeros;
    zeros.resize(dependentParam.n_vars);
    for (int i=0 ; i<dependentParam.n_vars ; ++i)
      zeros[i] = 0;
    dependentParam.expr->set_vars(zeros);
  }

  dependentParam.global_params.clear();
  if (!variables.empty())
  {
    for (iterS=variables.begin() ; iterS!=variables.end() ; ++iterS)
    {
      GlobalParameterMap::iterator global_param_it = globals_.global_params.find(*iterS);
      if (global_param_it == globals_.global_params.end())
      {
        UserError(*this) << "Global parameter " << *iterS << " not found";
      }
      else {
        dependentParam.expr->set_var(*iterS, (*global_param_it).second);
        dependentParam.global_params.push_back(*iterS);
      }
    }
  }
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::updateDependentParameters
// Purpose       : Update values of parameters defined as expressions
// Special Notes :
// Scope         : protected
// Creator       : Dave Shirley, PSSI
// Creation Date : 03/15/05
//-----------------------------------------------------------------------------
bool DeviceEntity::updateDependentParameters(const Linear::Vector & vars, bool changed)
{
  std::vector<Depend>::iterator dpIter = dependentParams_.begin();
  std::vector<Depend>::iterator end = dependentParams_.end();
  double rval(0.0);

  for ( ; dpIter != end ; ++dpIter)
  {
    if (dpIter->expr->set_sim_time(getSolverState().currTime_))
      changed = true;
    if (dpIter->expr->set_sim_dt(getSolverState().currTimeStep_))
    {
      // experiment with doing nothing....
      changed = true;
    }
    if (dpIter->expr->set_sim_freq(getSolverState().currFreq_))
    {
      // experiment with doing nothing....
      changed = true;
    }
    eVarVals.resize(dpIter->n_vars);
    if (dpIter->n_vars > 0)
    {
      int hi = dpIter->lo_var+dpIter->n_vars;
      for (int i = dpIter->lo_var; i < hi; ++i)
      {
        expVarVals[i] = vars[expVarLIDs[i]];
        eVarVals[i-dpIter->lo_var] = expVarVals[i];
      }
      if (dpIter->expr->set_vars(eVarVals))
        changed = true;
    }
    if (changed)
    {
      dpIter->expr->evaluateFunction (rval);
      if (dpIter->vectorIndex==-1)
        *(dpIter->resultU.result) = rval;
      else
        (*(dpIter->resultU.resVec))[dpIter->vectorIndex] = rval;

      if (dpIter->storeOriginal)
        Xyce::Device::setOriginalValue(*this,dpIter->serialNumber,rval);
    }
  }

  return changed;
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::updateGlobalParameters
// Purpose       : Update values of global parameters in expressions
// Special Notes :
// Scope         : protected
// Creator       : Dave Shirley, PSSI
// Creation Date : 11/17/05
//-----------------------------------------------------------------------------
bool DeviceEntity::updateGlobalParameters(GlobalParameterMap & global_map)
{
  std::vector<Depend>::iterator dpIter = dependentParams_.begin();
  std::vector<Depend>::iterator end = dependentParams_.end();
  double rval;
  int i, hi;
  bool changed = false;

  for ( ; dpIter != end ; ++dpIter)
  {
    if (!dpIter->global_params.empty())
    {
      std::vector<std::string>::iterator gp=dpIter->global_params.begin();
      std::vector<std::string>::iterator gend=dpIter->global_params.end();
      for ( ; gp != gend; ++gp)
      {
        if (global_map.find(*gp) == global_map.end())
        {
          DevelFatal(*this).in("DeviceEntity::updateGlobalParameters") << "Failed to find global parameter " << *gp;
        }
        if (dpIter->expr->set_var(*gp, global_map[*gp]))
          changed = true;
      }
    }
  }

  return changed;
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::updateDependentParameters
// Purpose       : Update values of parameters defined as expressions
// Special Notes :
// Scope         : protected
// Creator       : Dave Shirley, PSSI
// Creation Date : 11/18/04
//-----------------------------------------------------------------------------
bool DeviceEntity::updateDependentParameters()
{
  double rval;
  bool changed = false;

  std::vector<Depend>::iterator dpIter = dependentParams_.begin();
  std::vector<Depend>::iterator end = dependentParams_.end();
  for ( ; dpIter != end; ++dpIter)
  {
    if (dpIter->expr->set_sim_time( getSolverState().currTime_))
      changed = true;
    if (dpIter->expr->set_sim_dt(getSolverState().currTimeStep_))
    {
      // try doing nothing
      changed = true;
    }
    if (dpIter->expr->set_sim_freq(getSolverState().currFreq_))
    {
      // try doing nothing
      changed = true;
    }

    dpIter->expr->evaluateFunction (rval);
    if (dpIter->vectorIndex == -1)
      *(dpIter->resultU.result) = rval;
    else
      (*(dpIter->resultU.resVec))[dpIter->vectorIndex] = rval;
  }

  return changed;
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::updateDependentParameters
// Purpose       : Update values of parameters defined as expressions with a
//                 specified temperature
// Special Notes :
// Scope         : protected
// Creator       : Dave Shirley, PSSI
// Creation Date : 01/11/06
//-----------------------------------------------------------------------------
bool DeviceEntity::updateDependentParameters(double tempIn)
{
  double rval;
  bool changed = false;

  std::vector<Depend>::iterator dpIter = dependentParams_.begin();
  std::vector<Depend>::iterator end = dependentParams_.end();
  for ( ; dpIter != end; ++dpIter)
  {
    if (dpIter->expr->set_sim_time( getSolverState().currTime_ ) || dpIter->expr->set_temp(tempIn))
      changed = true;
    if (dpIter->expr->set_sim_dt(getSolverState().currTimeStep_))
    {
      // experiment with doing nothing
      changed = true;
    }
    if (dpIter->expr->set_sim_freq(getSolverState().currFreq_))
    {
      // experiment with doing nothing
      changed = true;
    }
    dpIter->expr->evaluateFunction (rval);
    if (dpIter->vectorIndex == -1)
      *(dpIter->resultU.result) = rval;
    else
      (*(dpIter->resultU.resVec))[dpIter->vectorIndex] = rval;

  }

  return changed;
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::getParamBreakpoints
// Purpose       : Add breakpoints caused by discontinuities in computed params
// Special Notes :
// Scope         : protected
// Creator       : Dave Shirley, PSSI
// Creation Date : 11/18/04
//-----------------------------------------------------------------------------
bool DeviceEntity::getParamBreakpoints( std::vector<Util::BreakPoint> & breakPointTimes )
{
  double bTime;

  std::vector<Depend>::iterator dpIter = dependentParams_.begin();
  std::vector<Depend>::iterator end = dependentParams_.end();
  for ( ; dpIter != end; ++dpIter)
  {
    bTime = dpIter->expr->get_break_time();
    if (bTime > getSolverState().currTime_)
      breakPointTimes.push_back(Util::BreakPoint(bTime));
  }

  return true;
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::given
// Purpose       : Return whether param was given
// Special Notes :
// Scope         : protected
// Creator       : Dave Shirley, PSSI
// Creation Date : 11/23/04
//-----------------------------------------------------------------------------
bool DeviceEntity::given( const std::string & parameter_name ) const
{
  ParameterMap::const_iterator it = getParameterMap().find(parameter_name);
  if (it == getParameterMap().end())
    DevelFatal(*this).in("DeviceEntity::given") << "Unrecognized parameter " << parameter_name;

  return Xyce::Device::wasValueGiven(*this, (*it).second->getSerialNumber());
}

//-----------------------------------------------------------------------------
// Function      : DeviceEntity::setParams
// Purpose       : Set parameters according to a vector of params.  Used to
//                 set instance or model parameter sets to netlist values
//
//                 This function also takes care of setting up necessary
//                 infrastructure when it is detected that a parameter
//                 has a value that is an expression dependent on time or
//                 other variables.  These will be added to a dependent
//                 variables vector for recomputation when the things they
//                 depend on change.
// Special Notes : Converted to member function from free function setParameters
//                 by Tom Russo.  The history of this function is somewhat
//                 bizarre, like its implementation, but at one point it was
//                 a protected member function, then was converted to a
//                 free function and renamed by Dave Baur, but only ever
//                 called by a wrapper member function called setParams.
//                 Since it was unclear why it was ever necessary for this
//                 two-layered calling sequence, I've converted it back
//                 to a single member function on 9/6/2016.
// Scope         : public
// Creator       : Dave Shirley, PSSI
// Creation Date : 11/20/04
//-----------------------------------------------------------------------------
Src_mod DeviceEntity::setParams(const std::vector<Param> &params)
{
  Src_mod mods = _STATIC_SRC; //default
    
  std::vector<Param>::const_iterator begin=params.begin();
  std::vector<Param>::const_iterator end=params.end();
  
  std::vector<std::string> composite_name_list;
  unordered_map<std::string, std::vector<CompositeParam *>, HashNoCase, EqualNoCase> composite_parameter_map;
  if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS))
  {
    Xyce::dout() << std::endl << "In DeviceEntity::setParams, for ";
    printName(Xyce::dout());
    Xyce::dout() << " parameters are:" << std::endl;
    for (std::vector<Param>::const_iterator it = begin; it != end; ++it)
    {
      const Param &param = *it;
      Xyce::dout() << "Param = " << param.tag() << ", Type = ";
      int tmpType = param.getType();
      switch (tmpType)
      {
        case Util::STR:
          Xyce::dout() << "STR";
          break;
        case Util::DBLE:
          Xyce::dout() << "DBLE";
          break;
        case Util::INT:
          Xyce::dout() << "INT";
          break;
        case Util::LNG:
          Xyce::dout() << "LNG";
          break;
        case Util::EXPR:
          Xyce::dout() << "EXPR";
          break;
        case Util::BOOL:
          Xyce::dout() << "BOOL";
          break;
        case Util::STR_VEC:
          Xyce::dout() << "STR_VEC";
          break;
        case Util::INT_VEC:
          Xyce::dout() << "INT_VEC";
          break;
        case Util::DBLE_VEC:
          Xyce::dout() << "DBLE_VEC";
          break;
        case Util::DBLE_VEC_IND:
          Xyce::dout() << "DBLE_VEC_IND";
          break;
        case Util::COMPOSITE:
          Xyce::dout() << "COMPOSITE";
          break;
        default:
          Xyce::dout() << "Unknown";
      }
      Xyce::dout() << ", Value = " << param.stringValue();

      if (param.given())
      {
        Xyce::dout() << "  given=TRUE";
      }
      else
      {
        Xyce::dout() << "  given=FALSE";
      }

      if (param.default_val())
      {
        Xyce::dout() << "  default=TRUE" << std::endl;
      }
      else
      {
        Xyce::dout() << "  default=FALSE" << std::endl;
      }
    }
    Xyce::dout() << std::endl;
  }

  for (std::vector<Param>::const_iterator param_it = begin; param_it != end; ++param_it)
  {
    Param &param = const_cast<Param &>(*param_it);

    const std::string &tag = param.tag();

    // Is this parameter in the Entity?
    ParameterMap::const_iterator entity_parameter_it = getParameterMap().find(tag);
    if (entity_parameter_it != getParameterMap().end())
    {
      const Descriptor &descriptor = *(*entity_parameter_it).second;
      if (descriptor.hasGivenMember())
      {
        if (param.given())
        {
          descriptor.setGiven(*this, true);
        }
        else if (descriptor.getGiven(*this))
        {
          continue;
        }
      }

      Xyce::Device::setValueGiven(*this, descriptor.getSerialNumber(), param.given());
      if (param.given() || param.default_val())
      {
        if ( param.getType() == Util::EXPR )
        {
          if (descriptor.isType<double>())
          {
            double val = setDependentParameter(param, &(descriptor.value<double>(*this)), descriptor.getExpressionAccess());
            param.setVal(val);
            if (descriptor.hasOriginalValueStored())
              Xyce::Device::setOriginalValue(*this,descriptor.getSerialNumber(), val);
          }
          else if (descriptor.isType<std::vector<double> >())
          {
            int ind = (descriptor.value<std::vector<double> >(*this)).size();
            double val = setDependentParameter (param, &(descriptor.value<std::vector<double> >(*this)), ind, descriptor.getExpressionAccess());
            (descriptor.value<std::vector<double> >(*this)).push_back(val);
          }
          else
          {
            DevelFatal(*this).in("DeviceEntity::setParams") << "Non double param " <<  tag << " cannot be set to expression";
          }
        }
        else
        {
          if (descriptor.isType<double>())
          {
            if (!param.isNumeric())
            {
              UserError(*this) << "Cannot convert parameter " << tag <<  " to a numeric value from " << param.stringValue();
              continue;
            }

            descriptor.value<double>(*this) = param.getImmutableValue<double>();
            if (isTempParam(tag) && descriptor.getAutoConvertTemperature())
            {
              descriptor.value<double>(*this) += CONSTCtoK;
            }
            if (descriptor.hasOriginalValueStored())
            {
              Xyce::Device::setOriginalValue(*this, descriptor.getSerialNumber(), descriptor.value<double>(*this));
            }
          }
          else if (descriptor.isType<std::string>())
          {
            descriptor.value<std::string>(*this) = param.stringValue();
          }
          else if (descriptor.isType<int>())
          {
            if (!param.isInteger())
            {
              UserError(*this) << "Cannot convert parameter " << tag << " to an integer value from " << param.stringValue();
              continue;
            }
            descriptor.value<int>(*this) = param.getImmutableValue<int>();
            if (descriptor.hasOriginalValueStored())
            {
              Xyce::Device::setOriginalValue(*this, descriptor.getSerialNumber(), static_cast<double> (descriptor.value<int>(*this)));
            }
          }
          else if (descriptor.isType<long>())
          {
            if (!param.isInteger())
            {
              UserError(*this) << "Cannot convert parameter " << tag << " to an integer value from " << param.stringValue();
              continue;
            }
            descriptor.value<long>(*this) = param.getImmutableValue<long>();
            if (descriptor.hasOriginalValueStored())
            {
              Xyce::Device::setOriginalValue(*this, descriptor.getSerialNumber(), static_cast<double> (descriptor.value<long>(*this)));
            }
          }
          else if (descriptor.isType<bool>())
          {
            if (!param.isBool())
            {
              UserError(*this) << "Cannot convert parameter " << tag << " to a logical value from " << param.stringValue();
              continue;
            }
            descriptor.value<bool>(*this) = param.getImmutableValue<bool>();
            if (descriptor.hasOriginalValueStored())
            {
              if (descriptor.value<bool>(*this))
              {
                Xyce::Device::setOriginalValue(*this, descriptor.getSerialNumber(), 1.0);
              }
              else
              {
                Xyce::Device::setOriginalValue(*this, descriptor.getSerialNumber(), 0.0);
              }
            }
          }
          else if (descriptor.isType<std::vector<int> >())
          {
            if (param.getType() == Util::INT_VEC)
            {
              (descriptor.value<std::vector<int> >(*this)) = param.getValue<std::vector<int> >();
            }
            else if (param.getType() == Util::INT)
            {
              (descriptor.value<std::vector<int> >(*this)).push_back(param.getImmutableValue<int>());
            }
          }
          else if (descriptor.isType<std::vector<double> >())
          {
            if (param.getType() == Util::DBLE_VEC)
            {
              (descriptor.value<std::vector<double> >(*this)) = param.getValue<std::vector<double> >();
            }
            else if (param.getType() == Util::DBLE)
            {
              (descriptor.value<std::vector<double> >(*this)).push_back(param.getImmutableValue<double>());
            }
          }
          else if (descriptor.isType<std::vector<std::string> >())
          {
            if (param.getType() == Util::STR_VEC)
            {
              (descriptor.value<std::vector<std::string> >(*this)) = param.getValue<std::vector<std::string> >();
            }
            else if (param.getType() == Util::STR)
            {
              (descriptor.value<std::vector<std::string> >(*this)).push_back(param.stringValue());
            }
          }
          else if (descriptor.hasCompositeData())
          {
            composite_parameter_map[tag].clear();
            composite_name_list.push_back(tag);

            // Note: ERK.  This push-back is done to process the base-param tag of a vector composite.
            // For example, if the composite parameters are things like REGION0.XWIDTH, where REGION
            // is the base parameter tag, 0 is the index, and XWIDTH is the subcomponent, the
            // tag that should be pushed back is tagES=REGION.
            //
            // Note: ERK:  This function seems to implicitly rely on the base parameter always preceeding
            // subcomponent parameters.  So REGION (alone) should preceed REGION0.XWIDTH in  the
            // STL vector params that is passed into this function.  If it doesn't then vc_stat will
            // stay false and a fatal error will get thrown.
            if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS))
            {
              Xyce::dout() << "pushing back composite " << tag << std::endl;
            }
          }
          else
          {
            DevelFatal(*this).in("DeviceEntity::setParams") << "Unknown type";
          }
        }
      }
    }

    // Is it a vector (why do nothing?)
    else if (param.stringValue() == "VECTOR")
    {
    }

    else if (tag == "URI")
    {
        mods = (Src_mod)(mods|_DYNAMIC_SRC);
    }

    // Must be a composite
    else
    {
      bool vc_stat = false;

      std::string::size_type dot = tag.find_first_of('.');
      if (dot != std::string::npos)
      {
        for (std::vector<std::string>::const_iterator it = composite_name_list.begin(); it != composite_name_list.end(); ++it)
        {
          const std::string &composite_name = *it;

          if (tag.find(composite_name) == 0) // Tag starts with the composite parameter name
          {
            std::string param_name(tag.begin() + dot + 1, tag.end());

            vc_stat = true;

            int n = 0;
            {
              std::istringstream is(std::string(tag.begin() + composite_name.size(), tag.begin() + dot));
              is >> n;
            }

            if (param_name == "NAME")
            {
              if (n != composite_parameter_map[composite_name].size())
              {
                DevelFatal(*this).in("DeviceEntity::setParams") << "Error filling 'NAME' vector param " <<  composite_name;
              }

              std::string name = param.stringValue();
              CompositeParam *composite = constructComposite(composite_name, name);
              composite_parameter_map[composite_name].push_back(composite);
              setDefaultParameters(*composite, composite->getParameterMap().begin(), composite->getParameterMap().end(), devOptions_);
            }
            else
            {
              if (n >= composite_parameter_map[composite_name].size())
              {
                UserFatal(*this) << "Error in definition of vector-composite parameter. "
                                 << "NAME parameter must be first parameter given in definition of " << composite_name;
              }
            }
            setParamFromVCParam(*composite_parameter_map[composite_name][n], composite_name, param_name, param);
          }
        }
      }
      if (!vc_stat)
      {
        UserFatal(*this) << "Unknown error while parsing possible vector-composite parameter";
      }
    }
  }

  if (!composite_name_list.empty())
  {
    for (std::vector<std::string>::const_iterator name_it = composite_name_list.begin(); name_it != composite_name_list.end(); ++name_it)
    {
      const std::string &vcs = *name_it;

      for (std::vector<CompositeParam *>::iterator it =  composite_parameter_map[vcs].begin(); it != composite_parameter_map[vcs].end(); ++it)
      {
        (*it)->processParams();
      }
    }
  }

  return mods;
}


//-----------------------------------------------------------------------------
// Function      : DeviceEntity::setParamFromVCParam
// Purpose       : Set values for a parameter contained within a 
//               : vector-composite parameter. 
// Special Notes : This was changed from a "free function" to a member function
//               : by Pete Sholander in December 2017.  That allowed the error 
//               : message to be improved (e.g., provide info on the device name).
// Scope         : public
// Creator       : Dave Shirley, PSSI
// Creation Date : 05/06/05
//-----------------------------------------------------------------------------
void DeviceEntity::setParamFromVCParam(CompositeParam &composite_param, 
				       const std::string & composite_name,
                                       const std::string & pName, 
                                       const Param & ndParam)
{
  ParameterMap::const_iterator p_i = composite_param.getParameterMap().find(pName);
  if (p_i != composite_param.getParameterMap().end())
  {
    const Descriptor &p = *(*p_i).second;
    if (p.hasGivenMember())
    {
      if (ndParam.given())
        p.setGiven(composite_param, true);
      else if (p.getGiven(composite_param))
        return;
    }
    Xyce::Device::setValueGiven(composite_param, p.getSerialNumber(), ndParam.given());
    if (ndParam.given() || ndParam.default_val())
    {
      if (p.isType<double>())
      {
        p.value<double>(composite_param) = ndParam.getImmutableValue<double>();
        if (isTempParam(pName) && p.getAutoConvertTemperature())
          p.value<double>(composite_param) += CONSTCtoK;
        if (p.hasOriginalValueStored())
          Xyce::Device::setOriginalValue(composite_param, p.getSerialNumber(), p.value<double>(composite_param));
      }
      else if (p.isType<std::string>())
      {
        p.value<std::string>(composite_param) = ndParam.stringValue();
      }
      else if (p.isType<int>())
      {
        p.value<int>(composite_param) = ndParam.getImmutableValue<int>();
        if (p.hasOriginalValueStored())
          Xyce::Device::setOriginalValue(composite_param, p.getSerialNumber(), static_cast<double>(p.value<int>(composite_param)));
      }
      else if (p.isType<long>())
      {
        p.value<long>(composite_param) = ndParam.getImmutableValue<long>();
        if (p.hasOriginalValueStored())
          Xyce::Device::setOriginalValue(composite_param, p.getSerialNumber(), static_cast<double>(p.value<long>(composite_param)));
      }
      else if (p.isType<bool>())
      {
        p.value<bool>(composite_param) = (ndParam.getImmutableValue<double>() != 0.0);
        if (p.hasOriginalValueStored())
        {
          if (p.value<bool>(composite_param))
            Xyce::Device::setOriginalValue(composite_param, p.getSerialNumber(), 1.0);
          else
            Xyce::Device::setOriginalValue(composite_param, p.getSerialNumber(), 0.0);
        }
      }
      else if (p.isType<std::vector<double> >())
      {
       (p.value<std::vector<double> >(composite_param)).push_back(ndParam.getImmutableValue<double>());
      }
      else if (p.isType<std::vector<std::string> >())
      {
        p.value<std::vector<std::string> >(composite_param).push_back(ndParam.stringValue());
      }
      else
      {
        Report::DevelFatal().in("DeviceEntity::setParamFromVCParam") << "Unknown parameter type for " << pName;
      }
    }
  }
  else
  {
    UserFatal(*this) << "Either vector-composite parameter " << composite_name 
                     << " is improperly formatted or parameter " <<  pName  
                     << " is not defined for this device or model type";
  }
}


void populateParams(const ParameterMap &parameter_map, std::vector<Param> &param_list, CompositeParamMap &composite_param_map)
{
  for (ParameterMap::const_iterator it = parameter_map.begin(); it != parameter_map.end(); ++it)
  {
    const Descriptor &param = *(*it).second;

    if (param.isType<double>())
    {
      if (param.getVec() == 0)
      {
        double val;
        if (isTempParam((*it).first) && param.getAutoConvertTemperature())
          val = getDefaultValue<double>(param) - CONSTCtoK;
        else
          val = getDefaultValue<double>(param);
        param_list.push_back(Param((*it).first, val));
      }
      else if (param.getVec() > 0)
      {
        if (param.getVec() == 1)
        {
          // This converts parameters link IC1, IC2 to just IC and type vector
          std::string vPar((*it).first.substr(0, (*it).first.size()-1));
          param_list.push_back(Param(vPar, "VECTOR"));
        }
        // We will also output IC1, IC2 as type double so they can
        // be specified as individual elements
        // This allows TC=a, b to also be specified as TC1=a TC2=b
        double val = getDefaultValue<double>(param);
        param_list.push_back(Param((*it).first, val));
      }
    }
    else if (param.isType<bool>())
    {
      if (param.getVec() == 0)
        param_list.push_back(Param((*it).first, getDefaultValue<bool>(param)));
      else if (param.getVec() > 0)
      {
        if (param.getVec() == 1)
        {
          std::string vPar((*it).first.substr(0, (*it).first.size()-1));
          param_list.push_back(Param(vPar, "VECTOR"));
        }
        // We will also output IC1, IC2 as type double so they can
        // be specified as individual elements
        // This allows TC=a, b to also be specified as TC1=a TC2=b
        bool val = getDefaultValue<bool>(param);
        param_list.push_back(Param((*it).first, val));
      }
    }
    else if (param.isType<int>())
    {
      if (param.getVec() == 0)
        param_list.push_back(Param((*it).first, getDefaultValue<int>(param)));
      else if (param.getVec() > 0)
      {
        if (param.getVec() == 1)
        {
          std::string vPar((*it).first.substr(0, (*it).first.size()-1));
          param_list.push_back(Param(vPar, "VECTOR"));
        }
        int val = getDefaultValue<int>(param);
        param_list.push_back(Param((*it).first, val));
      }
    }
    else if (param.isType<std::string>())
    {
      if (param.getVec() == 0)
        param_list.push_back(Param((*it).first, getDefaultValue<std::string>(param)));
      else if (param.getVec() > 0)
      {
        if (param.getVec() == 1)
        {
          std::string vPar((*it).first.substr(0, (*it).first.size()-1));
          param_list.push_back(Param(vPar, "VECTOR"));
        }
        std::string val = getDefaultValue<std::string>(param);
        param_list.push_back(Param((*it).first, val));
      }
    }
    else if (param.isType<std::vector<std::string> >())
    {
      Param vc((*it).first, std::vector<std::string>()); 
      param_list.push_back(vc);
    }
    else if (param.isType<std::vector<double> >())
    {
      Param vc((*it).first, std::vector<double>()); 
      param_list.push_back(vc);
    }
    else if (param.hasCompositeData())
    {
      Param vc2((*it).first, "VECTOR-COMPOSITE");
      vc2.setDefault(true);
      param_list.push_back(vc2);

      std::vector<Param> compositeParams;
      const ParametricData<CompositeParam> *c = param.getCompositeParametricData<CompositeParam>();

      if (c == 0)
      {
        Report::DevelFatal().in("populateParams") << "Vector-composite map for device type entity empty.";
      }

      // TODO: [DGB] I think when the Descriptor is refactored this will be clearer.  But this basically adds the
      //   type to the composite list with 'NAME' first.
      const ParametricData<CompositeParam> &d = *c;
      const ParameterMap &e = d.getMap();

      for (ParameterMap::const_iterator it4 = e.find("NAME"); it4 != e.end();) {
        const Descriptor &p = *(*it4).second;
        if (p.isType<double>())
          compositeParams.push_back(Param((*it4).first, getDefaultValue<double>(p)));
        else if (p.isType<bool>())
          compositeParams.push_back(Param((*it4).first, getDefaultValue<bool>(p)));
        else if (p.isType<int>())
          compositeParams.push_back(Param((*it4).first, getDefaultValue<int>(p)));
        else if (p.isType<std::string>())
          compositeParams.push_back(Param((*it4).first, getDefaultValue<std::string>(p)));
        if ((*it4).first == "NAME")
          it4 = e.begin();
        else
          it4++;
        if (it4 != e.end() && (*it4).first == "NAME")
          it4++;
      }

      composite_param_map[(*it).first] = compositeParams;
    }
    else
    {
      // Just skip these, like list of coupled inductors because not needed for metadata
      Xyce::dout() << "In final else clause of DeviceEntity::setParams().";
      if( param.isType<std::vector<std::string> >() )
        Xyce::dout() << " type is STR_VEC ";
      if( param.isType<std::vector<double> >() )
        Xyce::dout() << " type is DBLE_VEC ";
      Xyce::dout() << it->first << " this item is NOT being added to default parameter list." << std::endl;
    }
  }
}

} // namespace Device
} // namespace Xyce
src/DeviceModelPKG/Core/N_DEV_DeviceEntity.h0000644000175000017500000002702513660205157017076 0ustar  dkcdkc//-------------------------------------------------------------------------
//   Copyright 2002-2020 National Technology & Engineering Solutions of
//   Sandia, LLC (NTESS).  Under the terms of Contract DE-NA0003525 with
//   NTESS, the U.S. Government retains certain rights in this software.
//
//   This file is part of the Xyce(TM) Parallel Electrical Simulator.
//
//   Xyce(TM) 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 3 of the License, or
//   (at your option) any later version.
//
//   Xyce(TM) 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 Xyce(TM).
//   If not, see <http://www.gnu.org/licenses/>.
//-------------------------------------------------------------------------

//-----------------------------------------------------------------------------
//
// Purpose        : This file contains the device entity base class.
//
// Special Notes  :
//
// Creator        : Eric R. Keiter, SNL, Parallel Computational Sciences
//
// Creation Date  : 04/03/00
//
//
//
//
//-----------------------------------------------------------------------------


#ifndef Xyce_N_DEV_DeviceEntity_h
#define Xyce_N_DEV_DeviceEntity_h

#include <iosfwd>
#include <map>
#include <string>
#include <vector>

#include <N_DEV_fwd.h>
#include <N_IO_fwd.h>
#include <N_LAS_fwd.h>
#include <N_UTL_fwd.h>

#include <N_UTL_NetlistLocation.h>
#include <N_DEV_Pars.h>
#include <N_DEV_InstanceName.h>
#include <N_DEV_SourceData.h>

namespace Xyce {
namespace Device {

typedef std::map<std::string, std::vector<Param>, LessNoCase> CompositeParamMap;

void populateParams(const ParameterMap &parameter_map, std::vector<Param> &param_list, CompositeParamMap &composite_param_map);

//-----------------------------------------------------------------------------
// Class         : Depend
// Purpose       : Used to record information about dependent parameters
// Special Notes :
// Creator       : Dave Shirley
// Creation Date : 
//-----------------------------------------------------------------------------
///
///  The Depend struct is used to keep track of dependent parameters
///
struct Depend
{
  std::string                 name;      ///< parameter name
  Util::Expression *          expr;      ///< expression used comput value
  union resUnion
  {
    double *                result;
    std::vector<double> *   resVec;
  } resultU;                            ///< Holds a pointer to where the
                                        ///< parameter is stored.
  int                         vectorIndex; ///< Used if parameter is in a vector
  std::vector<double>         vals;     ///< values on which expression depends
  std::vector<std::string>    global_params; ///< global params on which
                                             ///< expression depends
  int                         n_vars, lo_var; 
  bool                     storeOriginal;    ///< true if original value stored
  int                      serialNumber;     ///< used if original value stored

  // Constructor
  Depend()
    : vectorIndex(-1), n_vars(0), lo_var(0)
  {};

};

//-----------------------------------------------------------------------------
// Class         : DeviceEntity
// Purpose       :
// Special Notes :
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 6/11/02
//-----------------------------------------------------------------------------
class DeviceEntity : public ParameterBase
{
public:
  DeviceEntity(
     ParametricData<void> &    parametric_data,
     const SolverState &       solver_state,
     const DeviceOptions &     device_options,
     const NetlistLocation &         netlist_location);

private:
  DeviceEntity(const DeviceEntity &);                   ///< No copying
  DeviceEntity &operator=(const DeviceEntity &);        ///< No assignment

public:
  virtual ~DeviceEntity();

  virtual bool processParams() = 0;

  virtual bool processInstanceParams() = 0;

  virtual CompositeParam *constructComposite(const std::string &composite_name, const std::string &param_name) 
  {
    return NULL;
  }

  bool setDefaultParam(double val, bool overrideOriginal=false);
  double getDefaultParam() const;

  bool scaleParam(const std::string & paramName, double val, double val0);
  bool scaleParam(const std::string & paramName, double val);
  bool scaleDefaultParam(double val);

  bool analyticSensitivityAvailable (const std::string & paramName);
  bool analyticSensitivityAvailableDefaultParam ();

  bool getAnalyticSensitivity ( const std::string & paramName,
                                std::vector<double> & dfdpVec,
                                std::vector<double> & dqdpVec,
                                std::vector<double> & dbdpVec,
                                std::vector<int> & FindicesVec,
                                std::vector<int> & QindicesVec,
                                std::vector<int> & BindicesVec );

  bool getAnalyticSensitivityDefaultParam ( std::vector<double> & dfdpVec,
                                std::vector<double> & dqdpVec,
                                std::vector<double> & dbdpVec,
                                std::vector<int> & FindicesVec,
                                std::vector<int> & QindicesVec,
                                std::vector<int> & BindicesVec );

  virtual bool getNumericalSensitivity ( const std::string & paramName,
                                std::vector<double> & dfdpVec,
                                std::vector<double> & dqdpVec,
                                std::vector<double> & dbdpVec,
                                std::vector<int> & FindicesVec,
                                std::vector<int> & QindicesVec,
                                std::vector<int> & BindicesVec ) = 0;

  bool getNumericalSensitivityDefaultParam ( std::vector<double> & dfdpVec,
                                std::vector<double> & dqdpVec,
                                std::vector<double> & dbdpVec,
                                std::vector<int> & FindicesVec,
                                std::vector<int> & QindicesVec,
                                std::vector<int> & BindicesVec );



//
  bool analyticMatrixSensitivityAvailable (const std::string & paramName);
  bool analyticMatrixSensitivityAvailableDefaultParam ();

  bool getAnalyticMatrixSensitivity ( const std::string & paramName,
    std::vector <std::vector<double> > & d_dfdx_dp,
    std::vector <std::vector<double> > & d_dqdx_dp,
    std::vector<int> & F_lids,
    std::vector<int> & Q_lids,
    std::vector< std::vector<int> > & F_jacLIDs,
    std::vector< std::vector<int> > & Q_jacLIDs );

  bool getAnalyticMatrixSensitivityDefaultParam (
    std::vector <std::vector<double> > & d_dfdx_dp,
    std::vector <std::vector<double> > & d_dqdx_dp,
    std::vector<int> & F_lids,
    std::vector<int> & Q_lids,
    std::vector< std::vector<int> > & F_jacLIDs,
    std::vector< std::vector<int> > & Q_jacLIDs );

  virtual bool getNumericalMatrixSensitivity ( const std::string & paramName,
    std::vector <std::vector<double> > & d_dfdx_dp,
    std::vector <std::vector<double> > & d_dqdx_dp,
    std::vector<int> & F_lids,
    std::vector<int> & Q_lids,
    std::vector< std::vector<int> > & F_jacLIDs,
    std::vector< std::vector<int> > & Q_jacLIDs ) = 0;

  bool getNumericalMatrixSensitivityDefaultParam (
    std::vector <std::vector<double> > & d_dfdx_dp,
    std::vector <std::vector<double> > & d_dqdx_dp,
    std::vector<int> & F_lids,
    std::vector<int> & Q_lids,
    std::vector< std::vector<int> > & F_jacLIDs,
    std::vector< std::vector<int> > & Q_jacLIDs );

//
  bool getAnalyticACSensitivityAvailable (const std::string & paramName);
  bool getAnalyticACSensitivityAvailableDefaultParam ();

  bool getAnalyticBSensVectorsforAC ( const std::string & paramName,
          std::vector< std::complex<double> > & dbdp,
          std::vector<int> &        BindicesVec);

  bool getAnalyticBSensVectorsforACDefaultParam (
          std::vector< std::complex<double> > & dbdp,
          std::vector<int> &        BindicesVec);

  virtual bool getNumericalBSensVectorsforAC ( const std::string & paramName,
          std::vector< std::complex<double> > & dbdp,
          std::vector<int> &        BindicesVec) = 0;

  bool getNumericalBSensVectorsforACDefaultParam (
          std::vector< std::complex<double> > & dbdp,
          std::vector<int> &        BindicesVec);
//
  bool setParam(const std::string & paramName, double val, bool overrideOriginal=false);
  bool getParam(const std::string & paramName, double & result) const;
  bool findParam(const std::string &param_name) const;
  bool getParamBreakpoints( std::vector<Util::BreakPoint> & );

  bool updateDependentParameters(const Linear::Vector & vars,bool changed=false);
  bool updateDependentParameters(double temp_tmp);
  bool updateGlobalParameters(GlobalParameterMap &);
  bool updateDependentParameters();

  double setDependentParameter(Util::Param &, double *, ParameterType::ExprAccess);
  double setDependentParameter(Util::Param &, std::vector<double> *, int , ParameterType::ExprAccess);
  void setDependentParameter(Util::Param & par, Depend & dependentParam, ParameterType::ExprAccess depend);

  void setDefaultParams() 
  {
    setDefaultParameters(*this, getParameterMap().begin(), getParameterMap().end(), devOptions_);
  }

  Src_mod setParams(const std::vector<Param> & params);

  // special handling for parameters contained within a vector-composite parameter
  void setParamFromVCParam(CompositeParam &composite_param,
                           const std::string &composite_name, 
                           const std::string &pName, 
                           const Param &ndParam);

public:
  bool given(const std::string & parameter_name) const;

  virtual std::ostream &printName(std::ostream &os) const = 0;

  void setDefaultParamName(const std::string &default_param_name) 
  {
    defaultParamName_ = default_param_name;
  }

  const std::string& getDefaultParamName() const { return defaultParamName_;}

  const std::vector<Depend> &getDependentParams() 
  {
    return dependentParams_;
  }

  void addDependentParameter(const Depend &param)
  {
    dependentParams_.push_back(param);
  }

  const DeviceOptions &getDeviceOptions() const 
  {
    return devOptions_;
  }

  const SolverState &getSolverState() const 
  {
    return solState_;
  }

  const NetlistLocation &netlistLocation() const 
  {
    return netlistLocation_;
  }

  const ParameterMap &getParameterMap() const 
  {
    return parametricData_.getMap();
  }

private:
  void escape(std::string &) const;
  void checkDepend(ParameterType::ExprAccess &);

private:
  std::string                 defaultParamName_;
  ParametricData<void> &      parametricData_;
  NetlistLocation             netlistLocation_;

  const SolverState &         solState_;
  Globals &                   globals_;

  const DeviceOptions &       devOptions_;
  std::vector<Depend>         dependentParams_;

protected:
  std::vector<int>            expVarGIDs;
  std::vector<int>            expVarLIDs;
  std::vector<std::string>    expVarNames;
  std::vector<double>         expVarVals;
  std::vector<double>         eVarVals;

public:
  inline const SolverState *solState()   const {return &solState_;} 
};

} // namespace Device
} // namespace Xyce

#endif // Xyce_N_DEV_DeviceEntity_h
src/DeviceModelPKG/Core/N_DEV_SourceData.C0000644000175000017500000031573113660205157016473 0ustar  dkcdkc//-------------------------------------------------------------------------
//   Copyright 2002-2020 National Technology & Engineering Solutions of
//   Sandia, LLC (NTESS).  Under the terms of Contract DE-NA0003525 with
//   NTESS, the U.S. Government retains certain rights in this software.
//
//   This file is part of the Xyce(TM) Parallel Electrical Simulator.
//
//   Xyce(TM) 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 3 of the License, or
//   (at your option) any later version.
//
//   Xyce(TM) 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 Xyce(TM).
//   If not, see <http://www.gnu.org/licenses/>.
//-------------------------------------------------------------------------

//-------------------------------------------------------------------------
//
// Purpose        : This file  contains the member functions of the
//                  N_DEV_SourceData class, which is used by the Vsrc
//                  and ISRC devices.
//
// Special Notes  :
//
// Creator        : Eric R. Keiter, SNL, Parallel Computational Sciences
//
// Creation Date  : 02/28/00
//
//
//
//
//-------------------------------------------------------------------------

#include <Xyce_config.h>

#include <fstream>

#include <N_DEV_DeviceInstance.h>
#include <N_DEV_DeviceOptions.h>
#include <N_DEV_Message.h>
#include <N_DEV_SolverState.h>
#include <N_DEV_SourceData.h>
#include <N_IO_DeviceBlock.h>
#include <N_IO_SpiceSeparatedFieldTool.h>
#include <N_UTL_BreakPoint.h>
#include <N_UTL_CheckIfValidFile.h>
#include <N_UTL_CheckIfValidURI.h>
#include <N_UTL_ExtendedString.h>
#include <N_UTL_FeatureTest.h>
#include <N_UTL_Math.h>

namespace Xyce {
namespace Device {

void
sourceFunctionMetadata(DeviceParamMap &sourceFcnMap)
{
  std::vector<Param> sourceFcnParamList;

  // Source function metadata.
  sourceFcnParamList.resize(7);
  sourceFcnParamList[0].set("V1", 0.0);
  sourceFcnParamList[1].set("V2", 0.0);
  sourceFcnParamList[2].set("TD", 0.0);
  sourceFcnParamList[3].set("TR", 0.0);
  sourceFcnParamList[4].set("TF", 0.0);
  sourceFcnParamList[5].set("PW", 0.0);
  sourceFcnParamList[6].set("PER", 0.0);
  sourceFcnMap[ "PULSE" ] = sourceFcnParamList;

  sourceFcnParamList.resize(7);
  sourceFcnParamList[0].set("VHI", 0.0);
  sourceFcnParamList[1].set("VLO", 0.0);
  sourceFcnParamList[2].set("TD", 0.0);
  sourceFcnParamList[3].set("TR", 0.0);
  sourceFcnParamList[4].set("TF", 0.0);
  sourceFcnParamList[5].set("TSAMPLE", 0.0);
  sourceFcnParamList[6].set("DATA", "");
  sourceFcnMap[ "PAT" ] = sourceFcnParamList;

  sourceFcnParamList.resize(6);
  sourceFcnParamList[0].set("V0", 0.0);
  sourceFcnParamList[1].set("VA", 0.0);
  sourceFcnParamList[2].set("FREQ", 0.0);
  sourceFcnParamList[3].set("TD", 0.0);
  sourceFcnParamList[4].set("THETA", 0.0);
  sourceFcnParamList[5].set("PHASE", 0.0);
  sourceFcnMap[ "SIN" ] = sourceFcnParamList;

  sourceFcnParamList.resize(6);
  sourceFcnParamList[0].set("V1", 0.0);
  sourceFcnParamList[1].set("V2", 0.0);
  sourceFcnParamList[2].set("TD1", 0.0);
  sourceFcnParamList[3].set("TAU1", 0.0);
  sourceFcnParamList[4].set("TD2", 0.0);
  sourceFcnParamList[5].set("TAU2", 0.0);
  sourceFcnMap[ "EXP" ] = sourceFcnParamList;

  sourceFcnParamList.resize(5);
  sourceFcnParamList[0].set("V0", 0.0);
  sourceFcnParamList[1].set("VA", 0.0);
  sourceFcnParamList[2].set("FC", 0.0);
  sourceFcnParamList[3].set("MDI", 0.0);
  sourceFcnParamList[4].set("FS", 0.0);
  sourceFcnMap[ "SFFM" ] = sourceFcnParamList;

  // sourceFcnParamList is empty for source function "PWL" indicating
  // that it needs special handling in NetlistHandler.C
  sourceFcnParamList.clear();
  sourceFcnMap[ "PWL" ] = sourceFcnParamList;

}

//----------------------------------------------------------------------------
// Function       : CircuitMetadata::getSourceFunctionParameters
// Purpose        :
// Special Notes  :
// Scope          : public
// Creator        : 
// Creation Date  : 
//----------------------------------------------------------------------------
const std::vector<Param> & getSourceFunctionParameters(const std::string & sourceFcn)
{
  static DeviceParamMap sourceFcnMap;

  if (sourceFcnMap.empty())
    sourceFunctionMetadata(sourceFcnMap);

  DeviceParamMap::const_iterator it = sourceFcnMap.find(sourceFcn);
  if (it == sourceFcnMap.end())
  {
    Report::DevelFatal() << "No such source function " << sourceFcn;
  }

  return (*it).second;
}

//-----------------------------------------------------------------------------
// Function      : getSourceFunctionID
// Purpose       : Return the integer value corresponding to the
//                 given source function. Return NUM_SRC_DATA if the given string
//                 is unknown.
// Special Notes :
// Scope         : public
// Creator       : Lon Waters
// Creation Date : 09/30/2003
//-----------------------------------------------------------------------------
int getSourceFunctionID(const std::string & sourceFcn)
{
  if (sourceFcn == "PULSE")     return _PULSE_DATA;
  else if (sourceFcn == "SIN")  return _SIN_DATA;
  else if (sourceFcn == "EXP")  return _EXP_DATA;
  else if (sourceFcn == "SFFM") return _SFFM_DATA;
  else if (sourceFcn == "PWL")  return _PWL_DATA;
  else if (sourceFcn == "PAT")  return _PAT_DATA;
  else if (sourceFcn == "DC")   return _DC_DATA;
  else if (sourceFcn == "AC")   return _AC_DATA;  //tmei: 05/02
  //else if (sourceFcn == "DISTOF1")   return _DISTOF1_DATA;
  //else if (sourceFcn == "DISTOF2")   return _DISTOF2_DATA;
  else if (sourceFcn == "PORT" || sourceFcn == "Z0"  )  return _PORT_DATA;
  else return _NUM_SRC_DATA;
}

//-----------------------------------------------------------------------------
// Function      : SourceData::SourceData
// Purpose       : constructor
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 4/24/00
//-----------------------------------------------------------------------------
SourceData::SourceData(const SolverState & ss1,
                       const DeviceOptions & do1)
  : sourceName_(""),
  typeName_(""),
  defaultParamName_(""),
  time(0.0),
  SourceValue(0.0),
  initializeFlag_(false),
  resetFlag_(true),
  solState_(ss1),
  devOptions_(do1),
  fastTimeScaleFlag_(false),
  realFlag_(true)
{}

//-----------------------------------------------------------------------------
// Function      : SourceData::~SourceData
// Purpose       : destructor
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 4/24/00
//-----------------------------------------------------------------------------
SourceData::~SourceData()
{}

//-----------------------------------------------------------------------------
// Function      : SourceData::initializeSource
// Purpose       : Base class initialization function.
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 9/04/01
//-----------------------------------------------------------------------------
bool SourceData::initializeSource ()
{
  initializeFlag_ = true;
  return true;
}

//-----------------------------------------------------------------------------
// Function      : SourceData::returnSource
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 4/24/00
//-----------------------------------------------------------------------------
double SourceData::returnSource()
{
  return SourceValue;
}

//-----------------------------------------------------------------------------
// Function      : SourceData::returnSource
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 4/24/00
//-----------------------------------------------------------------------------
std::string SourceData::getSourceTypeName()
{
  return typeName_;
}

//-----------------------------------------------------------------------------
// Function      : SourceData::printOutParams
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 6/21/00
//-----------------------------------------------------------------------------
void SourceData::printOutParams()
{}

//-----------------------------------------------------------------------------
// Function      : SourceData::getMaxTimeStepSize
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 4/01/02
//-----------------------------------------------------------------------------
double SourceData::getMaxTimeStepSize ()
{
  return devOptions_.defaultMaxTimeStep;
}

//-----------------------------------------------------------------------------
// Function      : SourceData::getTime_
// Purpose       :
// Special Notes :
// Scope         : protected
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 3/25/04
//-----------------------------------------------------------------------------
double   SourceData::getTime_() const
{
  double tmpTime = 0.0;

  if (fastTimeScaleFlag_)
    tmpTime = solState_.currFastTime_;
  else
    tmpTime = solState_.currTime_;

  if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) && solState_.debugTimeFlag)
  {
    Xyce::dout() << "SourceData::getTime.  time = " << tmpTime << std::endl
      << "SourceData::getTime.  currFastTime = " << solState_.currFastTime_ << std::endl
      << "SourceData::getTime.  currTime = " << solState_.currTime_ << std::endl;
  }

  return tmpTime;
}

// Class SinData

//-----------------------------------------------------------------------------
// Function      : SinData::SinData
// Purpose       : constructor
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 3/16/00
//
// From 3f5:  remember to incorporate this later:
//
//-----------------------------------------------------------------------------
#if 0
// this is from 3f5:
#define FREQ  (((here->VSRCfunctionOrder >=3) && (*(here->VSRCcoeffs+2)))? \
(*(here->VSRCcoeffs+2)):(1/ckt->CKTfinalTime))
#endif

SinData::SinData(
  const DeviceEntity &          device,
  const std::vector<Param> &    paramRef,
  const SolverState   &         ss1,
  const DeviceOptions &         do1)
: SourceData(ss1,do1),
  V0(0.0),
  VA(0.0),
  FREQ(0.0),
  TD(0.0),
  THETA(0.0),
  PHASE(0.0),
  V0given(false),
  VAgiven(false),
  FREQgiven(false),
  TDgiven(false),
  THETAgiven(false),
  PHASEgiven(false)
{
  std::vector<Param>::const_iterator iter = paramRef.begin();
  std::vector<Param>::const_iterator last = paramRef.end();

  for ( ; iter != last; ++iter)
  {
    const std::string & tmpname = iter->tag();

    if (tmpname == "V0")    { V0    = iter->getImmutableValue<double>(); V0given = iter->given();}
    if (tmpname == "VA")    { VA    = iter->getImmutableValue<double>(); VAgiven = iter->given();}
    if (tmpname == "FREQ")  { FREQ  = iter->getImmutableValue<double>(); FREQgiven = iter->given();}
    if (tmpname == "TD")    { TD    = iter->getImmutableValue<double>(); TDgiven = iter->given();}
    if (tmpname == "THETA") { THETA = iter->getImmutableValue<double>(); THETAgiven = iter->given();}
    if (tmpname == "PHASE") { PHASE = iter->getImmutableValue<double>(); PHASEgiven = iter->given();}
  }

  if (!(V0given && VAgiven && FREQgiven))
    UserError(device) << "V0, VA and FREQ are required for the SIN source function";

  typeName_ = "SIN";
  defaultParamName_ = "V0";
}

//-----------------------------------------------------------------------------
// Function      : SinData::initializeSource
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 9/04/01
//-----------------------------------------------------------------------------
bool SinData::initializeSource ()
{
  // If neccessary, set defaults:
  double tstop = solState_.finalTime_;

  if (!FREQgiven)  FREQ  = 1.0/tstop;
  if (!TDgiven)    TD    = 0.0;
  if (!THETAgiven) THETA = 0.0;

  initializeFlag_ = true;

  return true;
}

//-----------------------------------------------------------------------------
// Function      : SinData::~SinData
// Purpose       : destructor
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 3/16/00
//-----------------------------------------------------------------------------
SinData::~SinData()
{}

//-----------------------------------------------------------------------------
// Function      : SinData::printOutParams
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 6/21/00
//-----------------------------------------------------------------------------
void SinData::printOutParams()
{
  Xyce::dout() << "SinData:\n";
  Xyce::dout() << "V0 = "    << V0 << std::endl;
  Xyce::dout() << "VA = "    << VA << std::endl;
  Xyce::dout() << "FREQ = "  << FREQ << std::endl;
  Xyce::dout() << "TD = "    << TD << std::endl;
  Xyce::dout() << "THETA = " << THETA << std::endl;
  Xyce::dout() << "PHASE = " << PHASE << std::endl;
}

// Additional Declarations

//-----------------------------------------------------------------------------
// Function      : SinData::updateSource
// Purpose       : Update the sinwave source.
// Special Notes :
//
//   V0    - offset  (V or A)
//   VA    - Amplitude  (V or A)
//   FREQ  - frequency in Hz
//   TD    - delay in seconds
//   THETA - damping factor (Hz).
//   PHASE - phase (degrees)
//
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 4/24/00
//-----------------------------------------------------------------------------
bool SinData::updateSource()
{
  bool bsuccess = true;

  if (!initializeFlag_) bsuccess = initializeSource ();

  time = getTime_();

  time -= TD;
  double mpi = M_PI;
  if (time <= 0)
  {
    //SourceValue = V0;
    SourceValue = V0 + VA * sin (2.0*mpi*(PHASE/360)) ;
  }
  else
  {
    // 2PI to convert from hz to radians/sec
    SourceValue = V0 + VA * sin (2.0*mpi*(FREQ*time + PHASE/360)) *
      exp( -(time*THETA));
  }

  resetFlag_ = false;
  return bsuccess;
}

//-----------------------------------------------------------------------------
// Function      : SinData::getParams
// Purpose       : Pass back the sine source params.
// Special Notes : TD and FREQ are interchanged from their normal order
//                 to accomodate the storage layout in the device classes
//
// Scope         : public
// Creator       : Dave Shirley, PSSI
// Creation Date : 4/14/05
//-----------------------------------------------------------------------------
void SinData::getParams(double *params)
{
  params[0] = V0;
  params[1] = VA;
  params[2] = TD;
  params[3] = FREQ;
  params[4] = THETA;
  params[5] = PHASE;
}

//-----------------------------------------------------------------------------
// Function      : SinData::setParams
// Purpose       : Update the sine source params.
// Special Notes : TD and FREQ are interchanged from their normal order
//                 to accomodate the storage layout in the device classes
//
// Scope         : public
// Creator       : Dave Shirley, PSSI
// Creation Date : 4/14/05
//-----------------------------------------------------------------------------
void SinData::setParams(double *params)
{
  bool reset=false;
  if (V0 != params[0])
  {
    V0 = params[0];
    reset = true;
  }
  if (VA != params[1])
  {
    VA = params[1];
    reset = true;
  }
  if (TD != params[2])
  {
    TD = params[2];
    reset = true;
  }
  if (FREQ != params[3])
  {
    FREQ = params[3];
    reset = true;
  }
  if (THETA != params[4])
  {
    THETA = params[4];
    reset = true;
  }
  if (PHASE != params[5])
  {
    PHASE = params[5];
    reset = true;
  }
  if (reset)
  {
    updateSource();
  }
}

// Class ExpData

//-----------------------------------------------------------------------------
// Function      : ExpData::ExpData
// Purpose       : constructor
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 3/16/00
//-----------------------------------------------------------------------------
ExpData::ExpData(
  const DeviceEntity &          device,
  const std::vector<Param> &    paramRef,
  const SolverState   &         ss1,
  const DeviceOptions &         do1)
: SourceData(ss1,do1),
  V1   (0.0),
  V2   (0.0),
  TD1  (0.0),
  TAU1 (0.0),
  TD2  (0.0),
  TAU2 (0.0),
  V1given (false),
  V2given (false),
  TD1given (false),
  TAU1given (false),
  TD2given (false),
  TAU2given (false)
{
  // Set the user-defined params:
  std::vector<Param>::const_iterator iter = paramRef.begin();
  std::vector<Param>::const_iterator last = paramRef.end();

  for ( ; iter != last; ++iter)
  {
    const std::string & tmpname = iter->tag();

    if (tmpname == "V1")    { V1    = iter->getImmutableValue<double>(); V1given   = iter->given();}
    if (tmpname == "V2")    { V2    = iter->getImmutableValue<double>(); V2given   = iter->given();}
    if (tmpname == "TD1")   { TD1   = iter->getImmutableValue<double>(); TD1given  = iter->given();}
    if (tmpname == "TAU1")  { TAU1  = iter->getImmutableValue<double>(); TAU1given = iter->given();}
    if (tmpname == "TD2")   { TD2   = iter->getImmutableValue<double>(); TD2given  = iter->given();}
    if (tmpname == "TAU2")  { TAU2  = iter->getImmutableValue<double>(); TAU2given = iter->given();}
  }

  if (!(V1given && V2given))
    UserError(device) << "V1 and V2 are required for the EXP source function";

  typeName_ = "EXP";
  defaultParamName_ = "V1";
}

//-----------------------------------------------------------------------------
// Function      : ExpData::~ExpData
// Purpose       : destructor
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 3/16/00
//-----------------------------------------------------------------------------
ExpData::~ExpData()
{}

// Additional Declarations

//-----------------------------------------------------------------------------
// Function      : ExpData::printOutParams
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 6/21/00
//-----------------------------------------------------------------------------
void ExpData::printOutParams()
{
  Xyce::dout() << "ExpData:\n";

  Xyce::dout() << "V1 = " << V1 << std::endl;
  Xyce::dout() << "V2 = " << V2 << std::endl;

  Xyce::dout() << "TD1 = " << TD1 << std::endl;
  Xyce::dout() << "TAU1 = " << TAU1 << std::endl;

  Xyce::dout() << "TD2 = " << TD2 << std::endl;
  Xyce::dout() << "TAU2 = " << TAU2 << std::endl;
}

//-----------------------------------------------------------------------------
// Function      : ExpData::initializeSource
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 9/04/01
//-----------------------------------------------------------------------------
bool ExpData::initializeSource ()
{
  // If neccessary, set defaults:
  double tstep = solState_.startingTimeStep_;

  if (!TD1given)  TD1 = 0.0;
  if (!TAU1given) TAU1 = tstep;
  if (!TD2given)  TD2 = TD1 + tstep;
  if (!TAU2given) TAU2 = tstep;

  initializeFlag_ = true;

  return true;
}

//-----------------------------------------------------------------------------
// Function      : ExpData::updateSource
// Purpose       : Updates an exponential source:
// Special Notes :
//
//    V1    -  Initial value (V or A)
//    V2    -  Pulsed value (V or A).
//    TD1   -  Rise delay time (seconds).
//    TAU1  -  Rise time constant (seconds)
//    TD2   -  Fall delay time (seconds).
//    TAU2  -  Fall time constant (seconds)
//
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 4/24/00
//-----------------------------------------------------------------------------
bool ExpData::updateSource()
{
  bool bsuccess = true;

  if (!initializeFlag_) bsuccess = initializeSource ();

  time = getTime_();

  if (time <= TD1)
  {
    SourceValue = V1;
  }
  else if (time <= TD2)
  {
    SourceValue = V1 + (V2-V1)*(1-exp(-(time-TD1)/TAU1));
  }
  else
  {
    SourceValue = V1 + (V2-V1)*(1-exp(-(time-TD1)/TAU1)) +
      (V1-V2)*(1-exp(-(time-TD2)/TAU2)) ;
  }

  resetFlag_ = false;

  return bsuccess;
}

//-----------------------------------------------------------------------------
// Function      : ExpData::getParams
// Purpose       : Pass back the exponential source params.
// Special Notes :
//
// Scope         : public
// Creator       : Dave Shirley, PSSI
// Creation Date : 4/14/05
//-----------------------------------------------------------------------------
void ExpData::getParams(double *params)
{
  params[0] = V1;
  params[1] = V2;
  params[2] = TD1;
  params[3] = TAU1;
  params[4] = TD2;
  params[5] = TAU2;
}

//-----------------------------------------------------------------------------
// Function      : ExpData::setParams
// Purpose       : Update the exponential source params.
// Special Notes :
//
// Scope         : public
// Creator       : Dave Shirley, PSSI
// Creation Date : 4/14/05
//-----------------------------------------------------------------------------
void ExpData::setParams(double *params)
{
  bool reset=false;
  if (V1 != params[0])
  {
    V1 = params[0];
    reset = true;
  }
  if (V2 != params[1])
  {
    V2 = params[1];
    reset = true;
  }
  if (TD1 != params[2])
  {
    TD1 = params[2];
    reset = true;
  }
  if (TAU1 != params[3])
  {
    TAU1 = params[3];
    reset = true;
  }
  if (TD2 != params[4])
  {
    TD2 = params[4];
    reset = true;
  }
  if (TAU2 != params[5])
  {
    TAU2 = params[5];
    reset = true;
  }
  if (reset)
  {
    updateSource();
  }
}

// Class PulseData

//-----------------------------------------------------------------------------
// Function      : PulseData::PulseData
// Purpose       : constructor
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 3/16/00
//-----------------------------------------------------------------------------
PulseData::PulseData(
  const DeviceEntity &          device,
  const std::vector<Param> &    paramRef,
  const SolverState   &         ss1,
  const DeviceOptions &         do1)
: SourceData (ss1,do1),
  V1  (0.0),
  V2  (0.0),
  TD  (0.0),
  TR  (0.0),
  TF  (0.0),
  PW  (0.0),
  PER (0.0),
  V1given (false),
  V2given (false),
  TDgiven (false),
  TRgiven (false),
  TFgiven (false),
  PWgiven (false),
  PERgiven (false)
{
  // Get the user-defined values:
  std::vector<Param>::const_iterator iter = paramRef.begin();
  std::vector<Param>::const_iterator last = paramRef.end();

  for ( ; iter != last; ++iter)
  {
    const std::string & tmpname = iter->tag();

    if (tmpname == "V1")  { V1    = iter->getImmutableValue<double>(); V1given = iter->given();}
    if (tmpname == "V2")  { V2    = iter->getImmutableValue<double>(); V2given = iter->given();}
    if (tmpname == "TD")  { TD    = iter->getImmutableValue<double>(); TDgiven = iter->given();}
    if (tmpname == "TR")  { TR    = iter->getImmutableValue<double>(); TRgiven = iter->given();}
    if (tmpname == "TF")  { TF    = iter->getImmutableValue<double>(); TFgiven = iter->given();}
    if (tmpname == "PW")  { PW    = iter->getImmutableValue<double>(); PWgiven = iter->given();}
    if (tmpname == "PER") { PER   = iter->getImmutableValue<double>(); PERgiven = iter->given();}
  }

  // For HSpice compatibility, at least V1 must be given.  Note: that in
  // other Spicen (e.g, PSpice and ngspice), both V1 and V2 must be given.
  if (!V1given)
    UserError(device) << "V1 is required for the PULSE source function";

  typeName_ = "PULSE";
  defaultParamName_ = "V2";
}

//-----------------------------------------------------------------------------
// Function      : PulseData::~PulseData
// Purpose       : destructor
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 3/16/00
//-----------------------------------------------------------------------------
PulseData::~PulseData()
{}

// Additional Declarations

//-----------------------------------------------------------------------------
// Function      : PulseData::printOutParams
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 6/21/00
//-----------------------------------------------------------------------------
void PulseData::printOutParams()
{
  Xyce::dout() << std::endl;
  Xyce::dout() << "  PulseData::printOutParams\n";
  Xyce::dout() << "  V1  = "    << V1 << std::endl;
  Xyce::dout() << "  V2  = "    << V2 << std::endl;

  Xyce::dout() << "  TD  = "    << TD << std::endl;
  Xyce::dout() << "  TR  = "    << TR << std::endl;
  Xyce::dout() << "  TF  = "    << TF << std::endl;
  Xyce::dout() << "  PW  = "    << PW << std::endl;
  Xyce::dout() << "  PER = "    << PER << std::endl;
  Xyce::dout() << std::endl;
}

//-----------------------------------------------------------------------------
// Function      : PulseData::initializeSource
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 9/04/01
//-----------------------------------------------------------------------------
bool PulseData::initializeSource ()
{
  // If neccessary, set the defaults:

  double tstep = solState_.startingTimeStep_;
  double tstop = solState_.finalTime_;

  if (!TDgiven)  TD  = 0.0;
  if (!TRgiven)  TR  = tstep;
  if (!TFgiven)  TF  = tstep;
  if (!PWgiven)  PW  = tstop;
  if (!PERgiven) PER = tstop;

  initializeFlag_ = true;

  return true;
}

//-----------------------------------------------------------------------------
// Function      : PulseData::updateSource
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 4/24/00
//-----------------------------------------------------------------------------
bool PulseData::updateSource()
{
  //notused:  double tstep = solState_.startingTimeStep;
  //notused:  double tstop = solState_.finalTime_;
  bool bsuccess = true;

  if (!initializeFlag_) bsuccess = initializeSource ();

  double basetime = 0;
  if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) && solState_.debugTimeFlag)
  {
    Xyce::dout() << "  PulseData::updateSources\n";
    printOutParams();
  }

  time = getTime_();

  if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) && solState_.debugTimeFlag)
  {
    Xyce::dout() << "  Time = " << time << std::endl;
  }

  time -= TD;

  if (time > PER && PER != 0.0)
  {
    // repeating signal - figure out where we are in period
    basetime = PER * floor(time/PER);
    time -= basetime;
  }

  // This section got ugly because of a nasty roundoff bug.
  // Instead of doing "time > X" you need also check that time
  // is not within bptol of X.
  // So the following translation is used:
  // Instead of:                           we do:
  //  time > X                            time>X && fabs(time-x)>bptol
  //  time <= X                           time<X || fabs(time-x)<bptol

  if (time <= 0 || (time > (TR + PW + TF) &&
        (fabs (time - (TR+PW+TF)) > solState_.bpTol_) ) )
  {
    SourceValue = V1;
  }
  else if ((time > TR && fabs(time-TR) > solState_.bpTol_)
      && (time < (TR + PW) || fabs (time-(TR+PW))<solState_.bpTol_) )
  {
    SourceValue = V2;
  }
  else if (time > 0 &&
      (time < TR || fabs(time-TR) < solState_.bpTol_))
  {
    if (TR != 0.0)
    {
      SourceValue = V1 + (V2 - V1) * (time) / TR;
    }
    else
    {
      SourceValue = V1;
    }
  }
  else
  { // time > (TR + PW) && <= (TR + PW + TF)
    if (TF != 0.0)
    {
      SourceValue = V2 + (V1 - V2) * (time - (TR + PW)) / TF;
    }
    else
    {
      SourceValue = V2; //      SourceValue = 0.5 * (V1 + V2);
    }
  }

  if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) && solState_.debugTimeFlag)
  {
    Xyce::dout() << "  SourceValue = " << SourceValue << std::endl;
  }

  resetFlag_ = false;

  return bsuccess;
}

//-----------------------------------------------------------------------------
// Function      : PulseData::getParams
// Purpose       : Pass back the pulse source params.
// Special Notes :
//
// Scope         : public
// Creator       : Dave Shirley, PSSI
// Creation Date : 4/14/05
//-----------------------------------------------------------------------------
void PulseData::getParams(double *params)
{
  params[0] = V1;
  params[1] = V2;
  params[2] = TD;
  params[3] = TR;
  params[4] = TF;
  params[5] = PW;
  params[6] = PER;
}

//-----------------------------------------------------------------------------
// Function      : PulseData::setParams
// Purpose       : Update the pulse source params.
// Special Notes :
//
// Scope         : public
// Creator       : Dave Shirley, PSSI
// Creation Date : 4/14/05
//-----------------------------------------------------------------------------
void PulseData::setParams(double *params)
{
  bool reset=false;
  if (V1 != params[0])
  {
    V1 = params[0];
    reset = true;
  }
  if (V2 != params[1])
  {
    V2 = params[1];
    reset = true;
  }
  if (TD != params[2])
  {
    TD = params[2];
    reset = true;
  }
  if (TR != params[3])
  {
    TR = params[3];
    reset = true;
  }
  if (TF != params[4])
  {
    TF = params[4];
    reset = true;
  }
  if (PW != params[5])
  {
    PW = params[5];
    reset = true;
  }
  if (PER != params[6])
  {
    PER = params[6];
    reset = true;
  }
  if (reset)
  {
    updateSource();
  }
}

//-----------------------------------------------------------------------------
// Function      : PulseData::getBreakPoints
// Purpose       : This function adds break points to a vector of breakpoints.
//
//                 It does not bother to check them in any way, or put them
//                 in order.  It only adds them in.
//
// Special Notes : Like much of this file, this is adapted from spice 3f5.
//                 Some of the stuff in it is a little hokey, and may get
//                 removed or modified later.
//
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 06/08/01
//-----------------------------------------------------------------------------
bool PulseData::getBreakPoints
(std::vector<Util::BreakPoint> & breakPointTimes )
{
  bool bsuccess = true;

  if (!initializeFlag_) bsuccess = initializeSource ();

  // currPeriodIndex is the integer index representing the period of
  // the current circuit time.
  int currPeriodIndex = 0;

  // subtract out the delay.
  double basetime = 0.0;

  time = getTime_() - TD;

  if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) && solState_.debugTimeFlag)
  {
    Xyce::dout() << std::endl;
    Xyce::dout() << "  In PulseData::getBreakPoints\n";
    Xyce::dout() << "  time = " << time << std::endl;
    Xyce::dout() << "  TD   = " << TD  << std::endl;
    Xyce::dout() << "  PER  = " << PER << std::endl;
  }

  // repeating signal - figure out where we are in period
  if(time >= PER)
  {
    if (PER != 0.0)
    {
      currPeriodIndex = (static_cast<int> (floor(time/PER)));
      basetime = PER * (static_cast<double> (currPeriodIndex));
      time -= basetime;
    }
  }

  if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) && solState_.debugTimeFlag)
  {
    Xyce::dout() << "  time            = " << time << std::endl;
    Xyce::dout() << " basetime         = " << basetime << std::endl;
    Xyce::dout() << "  currPeriodIndex = " << currPeriodIndex << std::endl;
    Xyce::dout() << std::endl;
  }

  // now that we know which period this is, push_back all breakpoints
  // in this period and the next.  If we are still in the delay, then
  // just use first two periods.

  // current period:
  breakPointTimes.push_back(basetime+TD);
  breakPointTimes.push_back(basetime+TD+TR);
  breakPointTimes.push_back(basetime+TD+TR+PW);
  breakPointTimes.push_back(basetime+TD+TR+PW+TF);

  if (PER != 0.0)
  {
    breakPointTimes.push_back(basetime+TD+PER);

    // next period:
    breakPointTimes.push_back(basetime+TD+PER+TR);
    breakPointTimes.push_back(basetime+TD+PER+TR+PW);
    breakPointTimes.push_back(basetime+TD+PER+TR+PW+TF);
    breakPointTimes.push_back(basetime+TD+PER+PER);
  }

  return bsuccess;
}

//-----------------------------------------------------------------------------
// Function      : PulseData::getMaxTimeStepSize
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 9/25/01
//-----------------------------------------------------------------------------
double PulseData::getMaxTimeStepSize ()
{
  double maxTimeStep = devOptions_.defaultMaxTimeStep;

  // check if we are still in the delay or not.
  time = getTime_();

  if (time < TD) maxTimeStep = (0.1*TD );
  else           maxTimeStep = (0.1*PER);

  if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) && solState_.debugTimeFlag)
  {
    Xyce::dout() << "\nIn PulseData::getMaxTimeStepSize.  ";
    Xyce::dout() << " maxTimeStep = "<< maxTimeStep;
    Xyce::dout() << "  TD = " << TD << "  PER = " <<PER;
    Xyce::dout() << "  time = "<< time << std::endl;
  }

  return maxTimeStep;
}

// Class PWLinData

//-----------------------------------------------------------------------------
// Function      : PWLinData::PWLinData
// Purpose       : constructor
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 3/16/00
//-----------------------------------------------------------------------------
PWLinData::PWLinData(
  const DeviceEntity &          device,
  const std::vector<Param> &    paramRef,
  const SolverState &           ss1,
  const DeviceOptions &         do1,
  const std::string   &         t_name)
: SourceData(ss1,do1),
  NUM(0),
  REPEAT(false),
  REPEATTIME(0.0),
  TD(0.0),
  loc_(0),
  starttime_(0.0),
  preComputedBreakpointsDone(false)
{
  std::vector<Param>::const_iterator iter = paramRef.begin();
  std::vector<Param>::const_iterator last = paramRef.end();

  for ( ; iter != last; ++iter)
  {
    const std::string & tmpname = iter->tag();
    const bool & tmpgiven = iter->given();

    if (tmpname == "NUM")        NUM        = iter->getImmutableValue<int>();
    if (tmpname == "R" && tmpgiven == true)
    {
      REPEAT = true;
      REPEATTIME = iter->getImmutableValue<double>();
    }
    if (tmpname == "TD")         TD         = iter->getImmutableValue<double>();

    if ( tmpname == "T" && iter->given() )
    {
      time = iter->getImmutableValue<double>();
      ++iter;

      // The if statement handles the case where the first time-value pair is not (0,0).
      // It inserts a time-value pair at time=0, with the voltage level of the 
      // first user specified time-voltage pair.  This is compatible with what
      // PSpice and HSpice do.  The number of time-value pairs (NUM) is also 
      // incremented by 1, if that time-voltage pair at time=0 needs to be inserted.
      if ( TVVEC.empty() && time > 0.0 )
      {
        TVVEC.push_back(std::pair<double,double>(0.0,iter->getImmutableValue<double>()));
        NUM++;
      }

      TVVEC.push_back(std::pair<double,double>(time, iter->getImmutableValue<double>()));
    }
  }

  typeName_ = t_name; // DPWL for dynamically linked
  
  // an empty list of time-voltage pairs will likely fail parsing in 
  // extractSourceFields().  So, this error test may never be used.
  if (NUM == 0 && t_name == "PWL")
    UserError(device) << "At least one time-voltage pair must be specified for the PWL source function";

  // only do this test if the REPEAT parameter (R) is true
  if ( REPEAT && (REPEATTIME < 0 || REPEATTIME >=TVVEC[NUM-1].first) )
    UserError(device) << "PWL source repeat value (R) must be >= 0 and < last value in time-voltage list";
}

//-----------------------------------------------------------------------------
// Function      : PWLinData::~PWLinData
// Purpose       : destructor
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 3/16/00
//-----------------------------------------------------------------------------
PWLinData::~PWLinData()
{}

extern "C" {
    
static int NoConnection(PWLinDynData *,void *ext_data, PWLinDynData::BridgeOP op, void *op_data)
{
    return -1; // fatal error
}

tTVVEC *DeviceGetTVVEC(PWLinDynData *device) {
    return device->getTVVEC();
}
    
double DeviceGetTime(PWLinDynData *device) {
    return device->getTime_();
}
    
void DeviceResetNUM(PWLinDynData *device) {
    device->ResetNUM();
}
    
void DeviceRedoBreaks(PWLinDynData *device) {
    device->RecalculateBreaks();
}
    
    int DevAddBreak(PWLinDynData *device,double bp_time) {
    return device->addBreak(bp_time);
}
    
c_string DeviceGetTypName(PWLinDynData *device) {
    return device->getTypName();
}
    
c_string DeviceGetSrcName(PWLinDynData *device) {
    return device->getSrcName();
}
    
c_string DeviceGetPrmName(PWLinDynData *device) {
    return device->getPrmName();
}

double DeviceGetParam(DeviceInstance *dev_inst,const char *name,double dflt) {
    double val;
    if (dev_inst->getParam(name,val)) {
    }    
    return dflt;
}

c_string InstanceGetName(DeviceInstance *dev_inst) {

    const InstanceName &iname(dev_inst->getName());
    return iname.getEncodedName().c_str();
}

}

//-----------------------------------------------------------------------------
// Function      : PWLinDynData::PWLinDynData
// Purpose       : constructor
// Special Notes : just calls through to parent with different type name
// Creator       : Kevin Cameron
// Creation Date : 4/28/20
//-----------------------------------------------------------------------------
PWLinDynData::PWLinDynData(const DeviceEntity & device, const std::vector<Param> & paramRef,
            const SolverState   & ss1,
               const DeviceOptions & do1)
      : PWLinData(device, paramRef, ss1, do1, "DPWL")
{    
    std::vector<Param>::const_iterator iter = paramRef.begin();
    std::vector<Param>::const_iterator last = paramRef.end();

    BridgeFn     = NoConnection; // fail later
    BridgeFnData = NULL;
    next_bp      = 0.0;
    
    for ( ; iter != last; ++iter)
    {
        const std::string & tmpname = iter->tag();

        if (tmpname == "URI")  {
            std::string val(iter->getImmutableValue<std::string>());
            const char *cp     = val.c_str();
            const char *ep     = NULL;
            const char *lib_nm = NULL; // self
            const char *call   = "NoConnection";
            const char *args   = "";
            int l;
            if (0 == strncasecmp("code:",cp,5)) {
                cp += 5;
                if (NULL != (ep  = strstr(cp,":"))) {
                    char lib[1 + (l = (ep - cp))]; strncpy(lib,cp,l); lib[l] = '\0';
                    lib_nm = lib;
                    cp = ++ep;
                    if (NULL != (ep  = strstr(cp,":"))) {
                        char entry[1 + (l = (ep - cp))]; strncpy(entry,cp,l); entry[l] = '\0';
                        call = entry;
                        cp = ++ep;
                        if (*cp) {
                            args = cp;
                        }
                        BridgeFn = BindCB(lib_nm,call,args,&BridgeFnData);
                    } else {
                        BridgeFn = BindCB(lib_nm,call,args,&BridgeFnData);
                    }
                } 
            }
        }
    }
}


extern "C" {
#   define FN_DECL(ret,nm,argt,arg) ret nm argt;
#   include "N_DEV_SourceDataExt.inc"
}
    
//-----------------------------------------------------------------------------
// Function      : PWLinDynData::BindCB
// Purpose       : Load shared library and locate function
// Special Notes : just calls through to parent with different type name
// Creator       : Kevin Cameron
// Creation Date : 4/28/20
//-----------------------------------------------------------------------------
PWLinDynData::Callback PWLinDynData::BindCB(const char *lib_name,const char *fn_name,const char *args, void **cb_data)
{
    void *handle = NULL;
    void *(*fn)(...);

    static void *fns[] = {
#     define FN_DECL(ret,nm,argt,arg) (void *)nm,
#     include "N_DEV_SourceDataExt.inc"
      NULL
    };

    *cb_data = fns; // manual linking

#   define FN_DECL(ret,nm,argt,arg) e##nm, // bind names to index
    enum {
#     include "N_DEV_SourceDataExt.inc"
      eEnd
    };

    dlerror(); // clear reports
    
    Callback cbk = NoConnection;
    
    if (NULL != lib_name) {
        handle = dlopen(lib_name,RTLD_NOW);
        if (NULL == handle) {
            char *error = dlerror();
            Report::DevelFatal() << "Dynamic loading " << error;
            goto fail;
        }
    }

    if (NULL != (fn = (typeof(fn))dlsym(handle, fn_name))) {
        cbk = (Callback)(*fn)(this,cb_data,args);
    }
    
  fail:
    return cbk;
}

//-----------------------------------------------------------------------------
// Class         : PWLinDynData::~PWLinDynData
//
//
// Special Notes :
// Creator       : Kevin Cameron
// Creation Date : 4/28/20
//-----------------------------------------------------------------------------
PWLinDynData::~PWLinDynData()
{}

//-----------------------------------------------------------------------------
// Function      : PWLinData::printOutParams
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 6/21/00
//-----------------------------------------------------------------------------
void PWLinData::printOutParams()
{
  Xyce::dout() << std::endl;
  Xyce::dout() << "  NUM  = "    << NUM << std::endl;
  Xyce::dout() << "  REPEAT  = "    << REPEAT << std::endl;
  Xyce::dout() << "  REPEATTIME  = "    << REPEATTIME << std::endl;
  Xyce::dout() << "  TD  = "    << TD << std::endl;
  Xyce::dout() << "  loc_  = "    << loc_ << std::endl;
  Xyce::dout() << "  starttime_  = "    << starttime_ << std::endl;

  Xyce::dout() << "  Time    Voltage" << std::endl;
  for( int i = 0; i < NUM; ++i )
    Xyce::dout() << " " << TVVEC[i].first << "  " << TVVEC[i].second << std::endl;

  Xyce::dout() << std::endl;
}

// Additional Declarations

//-----------------------------------------------------------------------------
// Function      : PWLinData::updateSource
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 4/24/00
//-----------------------------------------------------------------------------
bool PWLinData::updateSource()
{
  bool bsuccess = true;

  if (!initializeFlag_) bsuccess = initializeSource ();

  if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) && solState_.debugTimeFlag)
  {
    Xyce::dout() << std::endl;
    Xyce::dout() << "  PWLinData::updateSource\n";
    printOutParams();
  }

  time = getTime_();

  if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) && solState_.debugTimeFlag)
  {
    Xyce::dout() << Xyce::section_divider << std::endl;
    Xyce::dout() << "  Time = " << time << std::endl;
  }

  double time1, time2, voltage1, voltage2;

  if( time >= TD )
  {
    time -= TD;

    if( time <= TVVEC[NUM-1].first )
    {
      for( int i = 0; i < NUM; ++i )
        if( time < TVVEC[i].first ) {loc_ = i;break;}

      if( loc_ == 0 )
      {
        time1 = 0.0;
        voltage1 = 0.0;
      }
      else
      {
        time1 = TVVEC[loc_-1].first;
        voltage1 = TVVEC[loc_-1].second;
      }
      time2 = TVVEC[loc_].first;
      voltage2 = TVVEC[loc_].second;

    }
    else if( !REPEAT )
    {
      // this has the net-effect of setting SourceValue = voltage2
      // when combined with the next if-else block
      time1 = 0.0;
      time2 = 1.0;
      voltage1 = voltage2 = TVVEC[NUM-1].second;
    }
    else
    {
      double looptime = TVVEC[NUM-1].first - REPEATTIME;
      time -= TVVEC[NUM-1].first;
      time -= looptime * floor(time / looptime);
      time += REPEATTIME;

      for( int i = 0; i < NUM; ++i )
      {
        if( time < TVVEC[i].first ) {loc_ = i;break;}
      }
      if (time == REPEATTIME)
      {
        time1 = 0.0;
        time2 = 1.0;
        voltage1 = voltage2 = TVVEC[NUM-1].second;
      }
      else
      {
        if( loc_ == 0 )
        {
          time1 = REPEATTIME;
          voltage1 = TVVEC[NUM-1].second;
        }
        else
        {
          time1 = TVVEC[loc_-1].first;
          voltage1 = TVVEC[loc_-1].second;
        }
        time2 = TVVEC[loc_].first;
        voltage2 = TVVEC[loc_].second;
      }

    }

    if( time1 == time2 || voltage1 == voltage2)
      SourceValue = voltage2;
    else
    {
      double length = time2 - time1;
      SourceValue = ( time2 - time ) * voltage1 / length;
      SourceValue += ( -time1 + time ) * voltage2 / length;
    }

    if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) && solState_.debugTimeFlag)
    {
      Xyce::dout() << "time: " << time << std::endl;
      Xyce::dout() << "time1: " << time1 << std::endl;
      Xyce::dout() << "time2: " << time2 << std::endl;
      Xyce::dout() << "voltage1: " << voltage1 << std::endl;
      Xyce::dout() << "voltage2: " << voltage2 << std::endl;
      Xyce::dout() << "Src: " << SourceValue << std::endl;
      Xyce::dout() << Xyce::section_divider << std::endl;
    }
  }
  else
  {
    SourceValue = 0.0;
  }

  resetFlag_ = false;

  return bsuccess;
}

//-----------------------------------------------------------------------------
// Function      : PWLinDynData::updateSource
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Kevin Cameron
// Creation Date : 4/29/2020
//-----------------------------------------------------------------------------
bool PWLinDynData::updateSource()
{
    CallBridge(Update,&TVVEC);
    bool sts = PWLinData::updateSource();

    if (next_bp > 0) {
        // double time = getTime_();
        // should maybe pull step in here
        next_bp = -1;
    }
    
    return sts;
}

//-----------------------------------------------------------------------------
// Function      : PWLinData::getBreakPoints
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 06/08/01
//-----------------------------------------------------------------------------
bool PWLinData::getBreakPoints
(std::vector<Util::BreakPoint> & breakPointTimes )
{
  bool bsuccess = true;

  if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) && solState_.debugTimeFlag)
  {
    Xyce::dout() << "  In PWLinData::getBreakPoints\n";
  }

  if (!initializeFlag_) bsuccess = initializeSource ();

  time = solState_.currTime_;

  time -= TD;

#if 1
  if (devOptions_.pwl_BP_off) { return true; }
#endif

  // if it's a repeating signal, figure out what period we are in
  if (REPEAT && time >= TVVEC[NUM - 1].first)
  {
    double loopBaseTime = 0.0;
    double bp_time;

    double looptime = TVVEC[NUM-1].first - REPEATTIME;
    loopBaseTime = looptime * (1.0 + floor((time - TVVEC[NUM - 1].first) / looptime));
    if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) && solState_.debugTimeFlag)
    {
      Xyce::dout() << "loopBaseTime: " << loopBaseTime << std::endl;
      Xyce::dout() << "floor function: " << floor((time - TVVEC[NUM - 1].first) / (TVVEC[NUM - 1].first - REPEATTIME)) << std::endl;
    }

    // now that we know which period this is, push_back all breakpoints
    // in this period and the next.
    for (int i = 0; i < NUM; ++i)
    {
      bp_time = TVVEC[i].first;
      if (bp_time >= REPEATTIME)
      {
        breakPointTimes.push_back(bp_time + loopBaseTime + TD);
        if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) && solState_.debugTimeFlag)
        {
          Xyce::dout() << "bp_time + loopBaseTime + TD: " << bp_time + loopBaseTime + TD << std::endl;
        }
      }
    }
  }
  else
  {
    // if this is not periodic, then only need to send the full set of BP once.
    if (!preComputedBreakpointsDone)
    {
      int origSize = breakPointTimes.size();
      breakPointTimes.reserve(origSize+NUM);
      for (int i = 0; i < NUM; ++i)
      {
        double bp_time = TVVEC[i].first;
        breakPointTimes.push_back(bp_time+TD);
        if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) && solState_.debugTimeFlag)
        {
          Xyce::dout() << "bp_time + TD: " << bp_time + TD << std::endl;
        }
      }
      preComputedBreakpointsDone = true;
    }
  }

  return bsuccess;
}

//-----------------------------------------------------------------------------
// Function      : PWLinData::getBreakPoints
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 06/08/01
//-----------------------------------------------------------------------------
bool PWLinDynData::getBreakPoints
(std::vector<Util::BreakPoint> & breakPointTimes )
{
  bool bsuccess = true;

  if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) && solState_.debugTimeFlag)
  {
    Xyce::dout() << "  In PWLinDynData::getBreakPoints\n";
  }

  if (!initializeFlag_) bsuccess = initializeSource ();

  time = solState_.currTime_;

  time -= TD;

  if (!preComputedBreakpointsDone)
  {
      int origSize = breakPointTimes.size();
      breakPointTimes.reserve(origSize+NUM);
      for (int i = 0; i < NUM; ++i)
      {
        double bp_time = TVVEC[i].first;
        breakPointTimes.push_back(bp_time+TD);
        if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) && solState_.debugTimeFlag)
        {
          Xyce::dout() << "bp_time + TD: " << bp_time + TD << std::endl;
        }
      }
      preComputedBreakpointsDone = true;
  }

  return bsuccess;
}

// Class PatData

//-----------------------------------------------------------------------------
// Function      : PatData::PatData
// Purpose       : constructor
// Special Notes :
// Scope         : public
// Creator       : Pete Sholander, SNL, Electrical Models & Simulation
// Creation Date : 3/19/2019
//-----------------------------------------------------------------------------
PatData::PatData(
  const DeviceEntity &          device,
  const std::vector<Param> &    paramRef,
  const SolverState &           ss1,
  const DeviceOptions &         do1)
: SourceData(ss1,do1),
  VHI(0),
  VLO(0),
  TD(0),
  TR(0),
  TF(0),
  TSAMPLE(0),
  DATA(""),
  RB(0),
  R(0),
  PATREPEATTIME(0),
  NUMDATA(0),
  NUMBP(0),
  loc_(0),
  starttime_(0.0)
{
  std::vector<Param>::const_iterator iter = paramRef.begin();
  std::vector<Param>::const_iterator last = paramRef.end();

  for ( ; iter != last; ++iter)
  {
    const std::string & tmpname = iter->tag();

    // required parameters
    if (tmpname == "VHI")     { VHI = iter->getImmutableValue<double>(); VHIgiven = iter->given(); }
    if (tmpname == "VLO")     { VLO = iter->getImmutableValue<double>(); VLOgiven = iter->given(); }
    if (tmpname == "TD")      { TD = iter->getImmutableValue<double>(); TDgiven = iter->given(); }
    if (tmpname == "TR")      { TR = iter->getImmutableValue<double>(); TRgiven = iter->given(); }
    if (tmpname == "TF")      { TF = iter->getImmutableValue<double>(); TFgiven = iter->given(); }
    if (tmpname == "TSAMPLE") { TSAMPLE = iter->getImmutableValue<double>(); TSAMPLEgiven = iter->given(); }

    if (tmpname == "DATA")
    {
      DATA = iter->getImmutableValue<std::string>();
      DATAgiven = iter->given();
    }

    // optional parameters
    if (tmpname == "RB")      { RB = iter->getImmutableValue<int>(); }
    if (tmpname == "R")       { R = iter->getImmutableValue<int>(); }
  }

  // check for required parameters
  if (!VHIgiven || !VLOgiven || !TDgiven || !TRgiven || !TFgiven || !TSAMPLEgiven || !DATAgiven)
    UserError(device) << "VHI, VLO, TD, TR, TF, TSAMPLE and DATA parameters are all required for PAT source";

  // negative sample, rise and fall times are not allowed.
  if ( (TSAMPLE <= 0) || (TR <= 0) || (TF <= 0) )
    UserError(device) << "TR, TF and TSAMPLE must all be non-negative for the PAT source function";

  // HSPICE sets R values less than -1 to 0.  R value of -1 means repeat the pattern "forever".
  if (R < -1) { R=0; }

  // HSPICE sets RB values less than 1 to 1.
  if (RB < 1) { RB=1; }
  if ( RB != 1 )
    UserError(device) << "Only RB=1 is supported for the PAT source function";

  // There must be at least one bit
  if ( ((DATA[0]!='B') && (DATA[0]!='b')) || DATA.size() < 2)
  {
    UserError(device) << "Invalid DATA field for the PAT source function";
  }
  else
  {
    NUMDATA = DATA.size()-1;
    size_t zeroCount = std::count(DATA.begin()+1, DATA.end(), '0');
    size_t oneCount  = std::count(DATA.begin()+1, DATA.end(), '1');
    if (zeroCount + oneCount != NUMDATA)
    {
      UserError(device) << "Invalid bit symbol in DATA field for the PAT source function";
    }
    else
    {
      updateTVVEC();
    }
  }

  NUMBP = TVVEC.size();

  typeName_ = "PAT";
}

//-----------------------------------------------------------------------------
// Function      : PatData::PatData
// Purpose       : destructor
// Special Notes :
// Scope         : public
// Creator       : Pete Sholander, SNL, Electrical Models & Simulation
// Creation Date : 3/19/19
//-----------------------------------------------------------------------------
PatData::~PatData()
{}

//-----------------------------------------------------------------------------
// Function      : PatData::printOutParams
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Pete Sholander, SNL, Electrical Models & Simulation
// Creation Date : 3/19/2019
//-----------------------------------------------------------------------------
void PatData::printOutParams()
{
  Xyce::dout() << std::endl;
  Xyce::dout() << "  VHI = "     << VHI << std::endl;
  Xyce::dout() << "  VLO = "     << VLO << std::endl;
  Xyce::dout() << "  TD = "      << TD << std::endl;
  Xyce::dout() << "  TR = "      << TR << std::endl;
  Xyce::dout() << "  TF = "      << TF << std::endl;
  Xyce::dout() << "  TSAMPLE = " << TSAMPLE << std::endl;
  Xyce::dout() << "  DATA = "    << DATA << std::endl;
  Xyce::dout() << "  R = "       << R << std::endl;
  Xyce::dout() << "  RB = "      << RB << std::endl;

  Xyce::dout() << "  Time    Voltage" << std::endl;
  for( int i = 0; i < NUMBP; ++i )
    Xyce::dout() << " " << TVVEC[i].first << "  " << TVVEC[i].second << std::endl;

  Xyce::dout() << std::endl;
}

// Additional Declarations

//-----------------------------------------------------------------------------
// Function      : PatData::updateSource
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Pete Sholander, SNL, Electrical Models & Simulation
// Creation Date : 3/19/2019
//-----------------------------------------------------------------------------
bool PatData::updateSource()
{
  bool bsuccess = true;

  if (!initializeFlag_) bsuccess = initializeSource ();

  if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) && solState_.debugTimeFlag)
  {
    Xyce::dout() << std::endl;
    Xyce::dout() << "  PatData::updateSource\n";
    printOutParams();
  }

  time = getTime_();
  time -= TD;  // account for the time delay

  if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) && solState_.debugTimeFlag)
  {
    Xyce::dout() << Xyce::section_divider << std::endl;
    Xyce::dout() << "  Time = " << time << std::endl;
  }

  double time1, time2, voltage1, voltage2;

  if( time <= TVVEC[1].first )
  {
    // Use the value in the second breakpoint for the initial value of the
    // first instance of the bit pattern.  The value in the first breakpoint
    // was set to 0.5*(VHI+VLO) in the constructor, if the first and last bits
    // in the the pattern are different.
    SourceValue = TVVEC[1].second;
  }
  else if ( (R >= 0) && (time >= R*NUMDATA*TSAMPLE + TVVEC[NUMBP-2].first) )
  {
    // After the waveform stops repeating, the value in the second-to-last breakpoint
    // is "held" for the rest for the simulation.  (Note: the value in the last
    // breakpoint was set to 0.5*(VHI+VLO) in the constructor, if the first and
    // last bits in the the pattern are different. So, the second-to-last value
    // is used instead of the last value.)
    SourceValue = TVVEC[NUMBP-2].second;
  }
  else
  {
    if (time <= TVVEC[NUMBP-1].first)
    {
      for( int i = 0; i < NUMBP; ++i )
        if( time < TVVEC[i].first ) {loc_ = i;break;}

      time1 = TVVEC[loc_-1].first;
      voltage1 = TVVEC[loc_-1].second;

      time2 = TVVEC[loc_].first;
      voltage2 = TVVEC[loc_].second;
    }
    else
    {
      double looptime = TVVEC[NUMBP-1].first - PATREPEATTIME;
      time -= TVVEC[NUMBP-1].first;
      time -= looptime * floor(time / looptime);
      time += PATREPEATTIME;

      for( int i = 0; i < NUMBP; ++i )
      {
        if( time < TVVEC[i].first ) {loc_ = i;break;}
      }

      if (time == PATREPEATTIME)
      {
        time1 = 0.0;
        time2 = 1.0;
        voltage1 = voltage2 = TVVEC[NUMBP-1].second;
      }
      else
      {
        if( loc_ == 0 )
        {
          time1 = PATREPEATTIME;
          voltage1 = TVVEC[NUMBP-1].second;
        }
        else
        {
          time1 = TVVEC[loc_-1].first;
          voltage1 = TVVEC[loc_-1].second;
        }
        time2 = TVVEC[loc_].first;
        voltage2 = TVVEC[loc_].second;
      }
    }

    if( time1 == time2 )
    {
      SourceValue = voltage2;
    }
    else
    {
      double length = time2 - time1;
      SourceValue = ( time2 - time ) * voltage1 / length;
      SourceValue += ( -time1 + time ) * voltage2 / length;
    }

    if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) && solState_.debugTimeFlag)
    {
      Xyce::dout() << "loc_: " << loc_ << std::endl;
      Xyce::dout() << "time: " << time << std::endl;
      Xyce::dout() << "time1: " << time1 << std::endl;
      Xyce::dout() << "time2: " << time2 << std::endl;
      Xyce::dout() << "voltage1: " << voltage1 << std::endl;
      Xyce::dout() << "voltage2: " << voltage2 << std::endl;
      Xyce::dout() << "Src: " << SourceValue << std::endl;
      Xyce::dout() << Xyce::section_divider << std::endl;
    }
  }

  resetFlag_ = false;

  return bsuccess;
}

//-----------------------------------------------------------------------------
// Function      : PatData::updateTVVEC
// Purpose       : Update the TVVEC, based on string in the DATA parameter
// Special Notes :
//
// Scope         : public
// Creator       : Pete Sholander, SNL
// Creation Date : 4/4/2019
//-----------------------------------------------------------------------------
void PatData::updateTVVEC()
{
  // Make TVVEC from the DATA field.  The first and last bits are special cases, as they
  // are made based on the assumption that the waveforms repeats.  The first/last
  // breakpoints will then be ignored (in updateSource()) for the first/last
  // repeat of the waveform.  (Note: R=0 is essentially repeating the waveform "once".)
  // Also: Note that TD will be added in both updateSource() and getBreakPoints(),
  // so it is not used here. Finally, this approach does not support RB yet.  So,
  // it assumes that RB=1.

  // clear() is needed for the .STEP case
  TVVEC.clear();

  if (DATA[1] == '1')
  {
    if (DATA[NUMDATA] == '0')
    {
      // Add the first breakpoint at the intermediate value if there will be
      // a bit flip at the start of a repeated cycle.
      TVVEC.push_back(std::pair<double,double>(0,0.5*(VHI-VLO)));
    }
    else
    {
      // This introduces extra breakpoints, but makes the "accounting"
      // for repeated waveforms easier in updateSource()
      TVVEC.push_back(std::pair<double,double>(0,VHI));
    }
    TVVEC.push_back(std::pair<double,double>(0.5*TR,VHI));
  }
  else if (DATA[1] == '0')
  {
    if (DATA[NUMDATA] == '0')
    {
      TVVEC.push_back(std::pair<double,double>(0,VLO));
    }
    else
    {
      // Add the first breakpoint at the intermediate value if there will be
      // a bit flip at the start of a repeated cycle.
      TVVEC.push_back(std::pair<double,double>(0,0.5*(VHI-VLO)));
    }
    TVVEC.push_back(std::pair<double,double>(0.5*TF,VLO));
  }

  for (int i=2;i<=NUMDATA;i++)
  {
    // Add breakpoints when data values change
    if (DATA[i] != DATA[i-1])
    {
      if (DATA[i] == '0')
      {
        // falling edge
        TVVEC.push_back(std::pair<double,double>(((i-1)*TSAMPLE) - 0.5*TF,VHI));
        TVVEC.push_back(std::pair<double,double>(((i-1)*TSAMPLE) + 0.5*TF,VLO));
      }
      else if (DATA[i] == '1')
      {
        // rising edge
        TVVEC.push_back(std::pair<double,double>(((i-1)*TSAMPLE) - 0.5*TR,VLO));
        TVVEC.push_back(std::pair<double,double>(((i-1)*TSAMPLE) + 0.5*TR,VHI));
      }
    }
  }

  // Handle the end of the last bit in the pattern, in a way that supports the
  // REPEAT feature.  This approach does not support RB yet.  So, it assumes that RB=1.
  if (DATA[NUMDATA] == '1')
  {
    TVVEC.push_back(std::pair<double,double>((NUMDATA*TSAMPLE)-0.5*TF,VHI));
    if ( DATA[1] != DATA[NUMDATA] )
    {
      TVVEC.push_back(std::pair<double,double>(NUMDATA*TSAMPLE,0.5*(VHI-VLO)));
    }
    else
    {
      TVVEC.push_back(std::pair<double,double>(NUMDATA*TSAMPLE,VHI));
    }
  }
  else if (DATA[NUMDATA] == '0')
  {
    TVVEC.push_back(std::pair<double,double>((NUMDATA*TSAMPLE)-0.5*TR,VLO));
    if ( DATA[1] != DATA[NUMDATA] )
    {
      TVVEC.push_back(std::pair<double,double>(NUMDATA*TSAMPLE,0.5*(VHI-VLO)));
    }
    else
    {
      TVVEC.push_back(std::pair<double,double>(NUMDATA*TSAMPLE,VLO));
    }
  }
}

//-----------------------------------------------------------------------------
// Function      : PatData::getParams
// Purpose       : Pass back the pulse source params.
// Special Notes :
//
// Scope         : public
// Creator       : Pete Sholander, SNL
// Creation Date : 4/4/2019
//-----------------------------------------------------------------------------
void PatData::getParams(double *params)
{
  params[0] = VHI;
  params[1] = VLO;
  params[2] = TD;
  params[3] = TR;
  params[4] = TF;
  params[5] = TSAMPLE;
}

//-----------------------------------------------------------------------------
// Function      : PulseData::setParams
// Purpose       : Update the pulse source params.
// Special Notes :
//
// Scope         : public
// Creator       : Pete Sholander, SNL
// Creation Date : 4/4/2019
//-----------------------------------------------------------------------------
void PatData::setParams(double *params)
{
  bool reset=false;
  if (VHI != params[0])
  {
    VHI = params[0];
    reset = true;
  }
  if (VLO != params[1])
  {
    VLO = params[1];
    reset = true;
  }
  if (TD != params[2])
  {
    TD = params[2];
    reset = true;
  }
  if (TR != params[3])
  {
    TR = params[3];
    reset = true;
  }
  if (TF != params[4])
  {
    TF = params[4];
    reset = true;
  }
  if (TSAMPLE != params[5])
  {
    TSAMPLE = params[5];
    reset = true;
  }

  if (reset)
  {
    updateTVVEC();
    updateSource();
  }
}

//-----------------------------------------------------------------------------
// Function      : PatData::getBreakPoints
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : pete Sholander, SNL, Electrical Models & Simulation
// Creation Date : 03/19/2019
//-----------------------------------------------------------------------------
bool PatData::getBreakPoints
(std::vector<Util::BreakPoint> & breakPointTimes )
{
  bool bsuccess = true;

  if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) && solState_.debugTimeFlag)
  {
    Xyce::dout() << "  In PatData::getBreakPoints\n";
  }

  if (!initializeFlag_) bsuccess = initializeSource ();

  time = solState_.currTime_;
  time -= TD;

  // if it's a repeating signal, figure out what period we are in
  if ( (R != 0) && (time >= TVVEC[NUMBP - 1].first))
  {
    double loopBaseTime = 0.0;
    double bp_time;

    double looptime = TVVEC[NUMBP-1].first - PATREPEATTIME;
    loopBaseTime = looptime * (1.0 + floor((time - TVVEC[NUMBP - 1].first) / looptime));
    if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) && solState_.debugTimeFlag)
    {
      Xyce::dout() << "loopBaseTime: " << loopBaseTime << std::endl;
      Xyce::dout() << "floor function: " << floor((time - TVVEC[NUMBP - 1].first) / (TVVEC[NUMBP - 1].first - PATREPEATTIME)) << std::endl;
    }

    for (int i = 0; i < NUMBP; ++i)
    {
      bp_time = TVVEC[i].first;
      if (bp_time >= PATREPEATTIME)
      {
        breakPointTimes.push_back(bp_time + loopBaseTime + TD);
        if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) && solState_.debugTimeFlag)
        {
          Xyce::dout() << "bp_time + loopBaseTime + TD: " << bp_time + loopBaseTime + TD << std::endl;
        }
      }
    }
  }
  else
  {
    for (int i = 0; i < NUMBP; ++i)
    {
      double bp_time = TVVEC[i].first;
      breakPointTimes.push_back(bp_time+TD);
      if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) && solState_.debugTimeFlag)
      {
        Xyce::dout() << "bp_time + TD: " << bp_time << std::endl;
      }
    }
  }

  return bsuccess;
}

// Class SFFMData

//-----------------------------------------------------------------------------
// Function      : SFFMData::SFFMData
// Purpose       : constructor
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 3/16/00
//-----------------------------------------------------------------------------

SFFMData::SFFMData(
  const DeviceEntity &          device,
  const std::vector<Param> &    paramRef,
  const SolverState   &         ss1,
  const DeviceOptions &         do1)
: SourceData(ss1,do1),
  V0  (0.0),
  VA  (0.0),
  FC  (0.0),
  MDI (0.0),
  FS  (0.0),
  V0given  (false),
  VAgiven  (false),
  FCgiven  (false),
  MDIgiven (false),
  FSgiven  (false)
{
  std::vector<Param>::const_iterator iter = paramRef.begin();
  std::vector<Param>::const_iterator last = paramRef.end();

  for ( ; iter != last; ++iter)
  {
    const std::string & tmpname = iter->tag();

    if (tmpname == "V0")  { V0    = iter->getImmutableValue<double>(); V0given = iter->given(); }
    if (tmpname == "VA")  { VA    = iter->getImmutableValue<double>(); VAgiven = iter->given(); }
    if (tmpname == "FC")  { FC    = iter->getImmutableValue<double>(); FCgiven = iter->given(); }
    if (tmpname == "MDI") { MDI   = iter->getImmutableValue<double>(); MDIgiven = iter->given(); }
    if (tmpname == "FS")  { FS    = iter->getImmutableValue<double>(); FSgiven = iter->given(); }
  }

  if (!(V0given && VAgiven))
    UserError(device) << "V0 and VA are required for the SFFM source function";

  typeName_ = "SFFM";
}

//-----------------------------------------------------------------------------
// Function      : SFFMData::~SFFMData
// Purpose       : destructor
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 3/16/00
//-----------------------------------------------------------------------------
SFFMData::~SFFMData()
{}

// Additional Declarations

//-----------------------------------------------------------------------------
// Function      : SFFMData::printOutParams
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 5/01/00
//-----------------------------------------------------------------------------

void SFFMData::printOutParams()
{
  Xyce::dout() << "SFFMData:\n";
  Xyce::dout() << "V0 = " << V0 << std::endl;
  Xyce::dout() << "VA = " << VA << std::endl;
  Xyce::dout() << "FC = " << FC << std::endl;
  Xyce::dout() << "MDI = " << MDI << std::endl;
  Xyce::dout() << "FS = " << FS << std::endl;
}

//-----------------------------------------------------------------------------
// Function      : SFFMData::initializeSource
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 9/04/01
//-----------------------------------------------------------------------------

bool SFFMData::initializeSource ()
{
  // If neccessary, set the defaults:
  double tstop = solState_.finalTime_;

  if (!FCgiven) FC = 1.0/tstop;
  if (!FSgiven) FS = 1.0/tstop;

  initializeFlag_ = true;

  return true;
}

//-----------------------------------------------------------------------------
// Function      : SFFMData::updateSource
// Purpose       :
// Special Notes :
//
//   V0    - offset  (V or A)
//   VA    - Amplitude  (V or A)
//   FC    - carrier frequency
//   MDI   - modulation index
//   FS    - signal frequency
//
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 4/24/00
//-----------------------------------------------------------------------------

bool SFFMData::updateSource()
{
  bool bsuccess = true;

  if (!initializeFlag_) bsuccess = initializeSource ();

  time = getTime_();

  double mpi = M_PI;
  SourceValue = V0 + VA * sin((2 * mpi * FC * time) +
      MDI * sin (2 * mpi * FS * time));

  resetFlag_ = false;

  return bsuccess;
}

//-----------------------------------------------------------------------------
// Function      : SFFMData::getParams
// Purpose       : Pass back the SFFM source params.
// Special Notes :
//
// Scope         : public
// Creator       : Dave Shirley, PSSI
// Creation Date : 4/14/05
//-----------------------------------------------------------------------------
void SFFMData::getParams(double *params)
{
  params[0] = V0;
  params[1] = VA;
  params[2] = FC;
  params[3] = MDI;
  params[4] = FS;
}

//-----------------------------------------------------------------------------
// Function      : SFFMData::setParams
// Purpose       : Update the SFFM source params.
// Special Notes :
//
// Scope         : public
// Creator       : Dave Shirley, PSSI
// Creation Date : 4/14/05
//-----------------------------------------------------------------------------
void SFFMData::setParams(double *params)
{
  bool reset=false;
  if (V0 != params[0])
  {
    V0 = params[0];
    reset = true;
  }
  if (VA != params[1])
  {
    VA = params[1];
    reset = true;
  }
  if (FC != params[2])
  {
    FC = params[2];
    reset = true;
  }
  if (MDI != params[3])
  {
    MDI = params[3];
    reset = true;
  }
  if (FS != params[4])
  {
    FS = params[4];
    reset = true;
  }
  if (reset)
    updateSource();
}

// Class ACData

//-----------------------------------------------------------------------------
// Function      : ACData::ACData
// Purpose       : constructor
// Special Notes :
// Scope         : public
// Creator       : Ting Mei, SNL
// Creation Date :
//-----------------------------------------------------------------------------
ACData::ACData(
  const DeviceEntity &          device,
  const std::vector<Param> &    paramRef,
  const SolverState   &         ss1,
  const DeviceOptions &         do1)
: SourceData(ss1,do1),
  ACMAG(1.0),
  ACPHASE(0.0),
  ACMAGgiven(false),
  ACPHASEgiven(false)
{
  std::vector<Param>::const_iterator iter = paramRef.begin();
  std::vector<Param>::const_iterator last = paramRef.end();

  for ( ; iter != last; ++iter)
  {
    const std::string & tmpname = iter->tag();

    if (tmpname == "ACMAG")    { ACMAG    = iter->getImmutableValue<double>(); ACMAGgiven = iter->given();}
    if (tmpname == "ACPHASE") { ACPHASE = iter->getImmutableValue<double>(); ACPHASEgiven = iter->given();}
  }

  typeName_ = "AC";
  defaultParamName_ = "ACMAG";
}

//-----------------------------------------------------------------------------
// Function      : ACData::~ACData
// Purpose       : destructor
// Special Notes :
// Scope         : public
// Creator       : Ting Mei, SNL
// Creation Date : 3/16/00
//-----------------------------------------------------------------------------
ACData::~ACData()
{}

//-----------------------------------------------------------------------------
// Function      : ACData::printOutParams
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Ting Mei, SNL
// Creation Date : 6/21/00
//-----------------------------------------------------------------------------
void ACData::printOutParams()
{
  Xyce::dout() << "ACData:\n";
  Xyce::dout() << "ACMAG = " << ACMAG << std::endl;
  Xyce::dout() << "ACPHASE = " << ACPHASE << std::endl;
}

//-----------------------------------------------------------------------------
// Function      : ACData::updateSource
// Purpose       : Update the sinwave source.
// Special Notes :
//
// Scope         : public
// Creator       : Ting Mei, SNL
// Creation Date :
//-----------------------------------------------------------------------------
bool ACData::updateSource()
{
  bool bsuccess = true;

  double mpi = M_PI;

  if (!initializeFlag_) bsuccess = initializeSource ();

  if (realFlag_)
  {
    SourceValue = ACMAG * cos(2.0*mpi*ACPHASE/360);
  }
  else
  {
    SourceValue = ACMAG * sin(2.0*mpi*ACPHASE/360);
  }

  if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS))
  {
    Xyce::dout() << "  SourceValue = " << SourceValue << std::endl;
  }

  resetFlag_ = false;

  return bsuccess;
}

//-----------------------------------------------------------------------------
// Function      : ACData::getParams
// Purpose       : Pass back the AC source params.
// Special Notes :
// Scope         : public
// Creator       : Ting Mei
// Creation Date :
//-----------------------------------------------------------------------------
void ACData::getParams(double *params)
{
  params[0] = ACMAG;
  params[1] = ACPHASE;
}

//-----------------------------------------------------------------------------
// Function      : ACData::setParams
// Purpose       : Update the AC source params.
// Special Notes :
//
// Scope         : public
// Creator       : Ting Mei
// Creation Date :
//-----------------------------------------------------------------------------
void ACData::setParams(double *params)
{
  bool reset=false;
  if (ACMAG!=  params[0])
  {
    ACMAG = params[0];
    reset = true;
  }
  if ( ACPHASE != params[1])
  {
    ACPHASE = params[1];
    reset = true;
  }
  if (reset)
    updateSource();
}


// Class ConstData

//-----------------------------------------------------------------------------
// Function      : ConstData::ConstData
// Purpose       : constructor
// Special Notes :
// Scope         : public
// Creator       : Robert Hoekstra, SNL, Parallel Computational Sciences
// Creation Date : 10/5/00
//-----------------------------------------------------------------------------

ConstData::ConstData(
  const DeviceEntity &          device,
  const std::vector<Param> &    paramRef,
  const SolverState   &         ss1,
  const DeviceOptions &         do1)
: SourceData(ss1,do1),
  V0(0.0)
{
  std::vector<Param>::const_iterator iter = paramRef.begin();
  std::vector<Param>::const_iterator last = paramRef.end();

  for ( ; iter != last; ++iter)
  {
    const std::string & tmpname = iter->tag();
    if (tmpname == "DCV0")
    {
      V0 = iter->getImmutableValue<double>();
    }
  }

  typeName_ = "CONST";
  defaultParamName_ = "DCV0";
  //  SourceValue = V0; // updateSource function is a no-op, essentially.
}

//-----------------------------------------------------------------------------
// Function      : ConstData::~ConstData
// Purpose       : destructor
// Special Notes :
// Scope         : public
// Creator       : Robert Hoekstra, SNL, Parallel Computational Sciences
// Creation Date : 10/5/00
//-----------------------------------------------------------------------------
ConstData::~ConstData()
{}

//-----------------------------------------------------------------------------
// Function      : ConstData::printOutParams
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Robert Hoekstra, SNL, Parallel Computational Sciences
// Creation Date : 10/5/00
//-----------------------------------------------------------------------------
void ConstData::printOutParams()
{
  Xyce::dout() << "ConstData:\n";
  Xyce::dout() << "V0: " << V0 << std::endl;
}

// Additional Declarations

//-----------------------------------------------------------------------------
// Function      : ConstData::updateSource
// Purpose       : Update the const source.
// Special Notes : ERK: this is now a no-op, as the source value is set in
//                 the constructor.  The value for this source never changes,
//                 so there isn't any point is re-setting the same value
//                 over and over.
//
// Scope         : public
// Creator       : Robert Hoekstra, SNL, Parallel Computational Sciences
// Creation Date : 10/5/00
//-----------------------------------------------------------------------------
bool ConstData::updateSource()
{
  bool bsuccess = true;

  if (!initializeFlag_) bsuccess = initializeSource ();

  SourceValue = V0;

  resetFlag_ = false;

  return bsuccess;
}

//-----------------------------------------------------------------------------
// Function      : ConstData::getParams
// Purpose       : Pass back the const source params.
// Special Notes :
//
// Scope         : public
// Creator       : Dave Shirley, PSSI
// Creation Date : 4/13/05
//-----------------------------------------------------------------------------
void ConstData::getParams(double *params)
{
  params[0] = V0;
}

//-----------------------------------------------------------------------------
// Function      : ConstData::setParams
// Purpose       : Update the const source params.
// Special Notes :
//
// Scope         : public
// Creator       : Dave Shirley, PSSI
// Creation Date : 4/13/05
//-----------------------------------------------------------------------------
void ConstData::setParams(double *params)
{
  if (V0 != params[0])
  {
    V0 = params[0];
    updateSource();
  }
}

//-----------------------------------------------------------------------------
// Function      : findSourceFieldPosition
// Purpose       : Find the position of a given field of an independent source
//                 in parsedLine_. Return the position if the field is found,
//                 otherwise return 0.
// Special Notes :
// Scope         : public
// Creator       : Lon Waters, SNL
// Creation Date : 10/02/2001
//-----------------------------------------------------------------------------
int
findSourceFieldPosition(
    const IO::TokenVector &       parsed_line,
    const std::string &           fieldToFind,
    int                           startPosition )
{
  size_t numFields = parsed_line.size();
  int fieldPosition = 0;

  if ( fieldToFind == "SOURCEFCN" ) // any transient source type.
  {
    ExtendedString field("");
    for ( size_t i = startPosition; i < numFields; ++i )
    {
      // The test here checks the field at position i to see if it
      // corresponds to a source function type registered in metadata.
      field = parsed_line[i].string_;
      field.toUpper();
      if ( getSourceFunctionID(field) != _NUM_SRC_DATA && // ie, not found
          getSourceFunctionID(field) != _AC_DATA  &&   // AC
          getSourceFunctionID(field) != _PORT_DATA ) //   port 
      {
        fieldPosition = i;
        break;
      }
    }
  }
  else
  {
    ExtendedString field("");
    for ( size_t i = startPosition; i < numFields; ++i )
    {
      field = parsed_line[i].string_;
      field.toUpper();
      if ( field == fieldToFind )
      {
        fieldPosition = i;
        break;
      }
    }
  }

  return fieldPosition;
}

//-----------------------------------------------------------------------------
// Function      : extractSourceData
// Purpose       : Extract the device data from parsedLine for independent
//                 source devices.
//
// Special Notes : Independent sources have the general form:
//
//   VXXXXXXX N+ N- <DC<> DC/TRAN VALUE> <AC <ACMAG <ACPHASE>>>
// + <DISTOF1 <F1MAG <F1PHASE>>> <DISTOF2 <F2MAG <F2PHASE>>>
//
// N+ and N- are the positive and negative nodes, respectively.
//
// DC/TRAN is the dc and transient analysis value of the source.
// The DC keyword is optional.
//
// ACMAG is the AC magnitude and ACPHASE is the AC phase. AC keyword and
// values only present if this is an AC source.
//
// DISTOF1 and DISTOF2 are the keywords that specify that the independent
// source has distortion inputs at the frequencies F1 and F2 respectively.
// These are not supported yet.
//
// Any independent source can be assigned a time-dependent value for
// transient analysis. If a source is assigned a time-dependent value,
// the time-zero value is used for dc analysis. There are five independent
// source functions: PULSE, EXP, SIN, PWL, and single-frequency FM (SFFM).
//
// Examples:
// VCC 10 0 DC 6
// VIN 13 2 0.001 AC 1 SIN(0 1 1MEG)
// ISRC 23 21 AC 0.333 45.0 SFFM(0 1 10K 5 1K)
// VMEAS 12 9
// VCARRIER 1 0 DISTOF1 0.1 -90.0
// VMODULATOR 2 0 DISTOF2 0.01
// IIN1 1 5 AC 1 DISTOF1 DISTOF2 0.001
//
// Scope         : public
// Creator       : Lon Waters, SNL
// Creation Date : 09/25/2001
//-----------------------------------------------------------------------------
bool
extractSourceData(
    const IO::TokenVector &   parsedInputLine,
    IO::DeviceBlock &         device_block,
    const std::string &       primaryDeviceParameter)
{
  int numFields = parsedInputLine.size();
  bool tranGiven=false;
  bool acGiven=false;
//  bool dcGiven=true;

  bool dcGiven=false;

  bool portGiven=false;           // check to see if needed      ?? 
  bool z0Given=false;

  // Extract the source device nodes.
  device_block.extractNodes(parsedInputLine, -1, 0);

  // Set up the "primary" parameter.  (for vsrc's this is V0 by default, and is DC)
  Util::Param primaryParameter( "", "" );
  primaryParameter.setTag(primaryDeviceParameter);
  primaryParameter.setVal("0");
  int tranSourceType = _DC_DATA;

  // Set position on line to first field after the nodes.
  int linePosition = device_block.getNumberOfNodes() + 1;

  // Check for DC field.  If present, then reset DC parameter (default parameter)
  // to the value from the netlist.  The DC value is "special" because
  // it doesn't require a DC keyword in front of it.  Also, it is always the
  // first type specified on the instance line.
  //
  // All other src types require a keyword.  So, the handling is different.
  if ( linePosition < numFields )
  {
    ExtendedString field(parsedInputLine[linePosition].string_);
    field.toUpper();
    int sourceID = getSourceFunctionID(field);
    // The field is the DC field, advance past "DC" keyword.
    if ( sourceID == _DC_DATA )
    {
      ++linePosition ;
      if (linePosition < numFields)
      {
        field = parsedInputLine[linePosition].string_;
        field.toUpper();
        sourceID = getSourceFunctionID(field);
        dcGiven=true;

      }
      else
      {
        Report::UserError().at(device_block.getNetlistFilename(), device_block.getLineNumber())
          << "Line for device " << device_block.getInstanceName() << " is missing a value or expression after DC field";
        return false;
      }
    }

    // If the field is NOT related to any recognized non-DC
    // source, then proceed.
    if ( sourceID == _NUM_SRC_DATA )  // ie, type not found
    {
      // Get the DC value.
      if ( linePosition < numFields )
      {
        primaryParameter.setVal( parsedInputLine[linePosition].string_ );
        ++linePosition;

        dcGiven = true;

        // generate error message if DC value is invalid
        if( !( primaryParameter.isNumeric() || primaryParameter.hasExpressionValue() ) )
        {
          Report::UserError().at(device_block.getNetlistFilename(), device_block.getLineNumber())
            << "Invalid DC value \"" << primaryParameter.stringValue() << "\" for device " << device_block.getInstanceName();
          return false;
        }
      }
    }
    else
    {
      // no-op.  primary param was already set to zero.
    }
  }

  // Find the positions of the "AC", "DISTOF1", "DISTOF2", and source
  // function fields in parsedInputLine. Save names and positions of the
  // fields that appear in parsedLine in fieldNames and fieldPositions.
  std::vector<std::string> fieldNames;
  std::vector<int> fieldPositions;

  int fieldPosition = findSourceFieldPosition(parsedInputLine, "AC", linePosition );
  if ( fieldPosition > 0 )
  {
    fieldNames.push_back( "AC" );
    fieldPositions.push_back( fieldPosition );
    acGiven=true;
    //    tranSourceType = getSourceFunctionID("AC"); //tmei: 05/02
    //    ++linePosition;
  }

  fieldPosition = findSourceFieldPosition(parsedInputLine, "DISTOF1", linePosition );
  if ( fieldPosition > 0 )
  {
    fieldNames.push_back( "DISTOF1" );
    fieldPositions.push_back( fieldPosition );
  }

  fieldPosition = findSourceFieldPosition(parsedInputLine, "DISTOF2", linePosition );
  if ( fieldPosition > 0 )
  {
    fieldNames.push_back( "DISTOF2" );
    fieldPositions.push_back( fieldPosition );
  }

  fieldPosition = findSourceFieldPosition(parsedInputLine, "SOURCEFCN", linePosition );
  if ( fieldPosition > 0 )
  {
    fieldNames.push_back( "SOURCEFCN" );
    fieldPositions.push_back( fieldPosition );
    ExtendedString field( parsedInputLine[fieldPosition].string_ );
    field.toUpper();
    tranSourceType = getSourceFunctionID(field);
    tranGiven=true;
  }
  else
  {
    tranGiven=false;
  }

  // Set the type(s) of the source.
  fieldPosition = findSourceFieldPosition(parsedInputLine, "PORT", linePosition );
  if ( fieldPosition > 0 )
  {
    fieldNames.push_back( "PORT" );
    fieldPositions.push_back( fieldPosition );
    portGiven=true; 
  }   


  fieldPosition = findSourceFieldPosition(parsedInputLine, "Z0", linePosition );
  if ( fieldPosition > 0 )
  {
    fieldNames.push_back( "Z0" );
    fieldPositions.push_back( fieldPosition );
    z0Given=true;  
  }

  // Set the type(s) of the source.

  Util::Param tranSourceTypeParameter( "TRANSIENTSOURCETYPE", tranSourceType );
  Util::Param acSourceTypeParameter( "ACSOURCETYPE", (int) _AC_DATA);
  Util::Param dcSourceTypeParameter( "DCSOURCETYPE", (int) _DC_DATA);

  // Add the device instance parameters and their default values
  // to instanceParameters and extract instance parameters from
  // parsedInputLine.

  int parameterStartPosition;
  int parameterEndPosition;
  device_block.extractInstanceParameters( parsedInputLine,
      linePosition,
      parameterStartPosition,
      parameterEndPosition,
      "continue");
  fieldNames.push_back( "PARAMS" );
  fieldPositions.push_back( parameterStartPosition );

  // ERK.  Before extractSourceFields can be called, the field vectors
  // need to be in order of ascending field position.
  //
  // This loop below does a quick insertion sort.
  // (see the insort routine from: http://www.yendor.com/programming/sort/)
  //
  // It is quick // as long as the field arrays are less than 15 elements.  I did
  // not use STL sort b/c I am sorting using the contents of fieldPositions,
  // but fieldNames must also be sorted the same way.
  int len = fieldPositions.size();
  for (int i = 1; i < len; i++)
  {
    int j = i;
    int temp = fieldPositions[j];
    std::string tmpName =  fieldNames[j];
    while (j > 0 && (fieldPositions[j-1] > temp))
    {
      fieldPositions[j] = fieldPositions[j-1];
      fieldNames[j] = fieldNames[j-1];
      j--;
    }
    fieldPositions[j] = temp;
    fieldNames[j] = tmpName;
  }

  // Extract the "AC", "DISTOF1", "DISTOF2", and transient
  // source function fields if they appear in parsedInputLine.
  bool result = extractSourceFields(parsedInputLine, device_block, fieldNames, fieldPositions );
  if ( !result )
  {
    return false;
  }

  // Set the DC value.
  Param * parameterPtr;
  if ( primaryParameter.tag() != "" )
  {
    parameterPtr = device_block.findInstanceParameter( primaryParameter );
    parameterPtr->setVal( primaryParameter );
    parameterPtr->setGiven( true );
  }

  // Set the transient source type.
  parameterPtr = device_block.findInstanceParameter( tranSourceTypeParameter );
  parameterPtr->setVal( tranSourceTypeParameter );
  parameterPtr->setGiven( tranGiven );

  // Set the AC source type, if it was given
  parameterPtr = device_block.findInstanceParameter( acSourceTypeParameter );
  parameterPtr->setVal( acSourceTypeParameter );
  parameterPtr->setGiven( acGiven );

  // Set the DC source type, if it was given
  parameterPtr = device_block.findInstanceParameter( dcSourceTypeParameter );
  parameterPtr->setVal( dcSourceTypeParameter );
  parameterPtr->setGiven( dcGiven );

  return true; // Only get here on success.
}

//-----------------------------------------------------------------------------
// Function      : extractSourceFields
//
// Purpose       : This function loops through the fields on a source instance
//                 line, processes them, adding defaults when necessary, and
//                 then adds them to the instance parameter database for
//                 this device.
//
// Special Notes : ERK:  this function does at least one really strange thing.
//                 Instead of plugging values into existing metadata, the
//                 parameters for the given source type are added to the
//                 metadata container.  So, for example, if the user has
//                 set V1, and V1 is already in the metadata, this function
//                 does not set the existing V1.  It adds a new one so that
//                 two instances of V1 are present.
//
//                 In practice, this still works, as the devices (vsrc and
//                 isrc) will use the last value set for any parameter,
//                 and the "added" version is the last value.  However,
//                 for a develoer it is confusing.
//
//                 I think the reason for the "adding" is the PWL source,
//                 which can have an arbitrary number of entries.
//
// Scope         : public
// Creator       : Lon Waters, SNL
// Creation Date : 10/03/2001
//-----------------------------------------------------------------------------
bool
extractSourceFields(
    const IO::TokenVector &               parsedInputLine,
    IO::DeviceBlock &                     device_block,
    const std::vector<std::string> &      fieldNames,
    const std::vector<int> &              fieldPositions )
{
  if ( fieldNames[0] == "PARAMS" )
  {
    // No fields to extract.
    return true;
  }

  // Iterate through the fieldNames and extract the corresponding data
  // for the field. The fieldPositions vector gives the position in
  // parsedLine at which the fieldNames appear.
  int i;
  int numFields = fieldNames.size();
  for ( i = 0; i < numFields; ++i )
  {
    //    if ( fieldNames[i] == "AC" || fieldNames[i] == "DISTOF1" ||
    //         fieldNames[i] == "DISTOF2" )
    if ( fieldNames[i] == "AC")
    {
      // The code here inserts instance parameters for magnitude and phase
      // of AC stimulus.
      Param mag("", "");
      Param phase("", "");

      int numTerms = fieldPositions[i+1] - fieldPositions[i] - 1;

      std::string magName(fieldNames[i] + "MAG");
      std::string phaseName(fieldNames[i] + "PHASE");
      mag.set( magName, "1.0" );
      phase.set( phaseName, "0.0" );

      if ( numTerms > 2 )
      {
        device_block.issueUnrecognizedParameterError(fieldNames[i]+" Too Many Terms");
      }

      if ( numTerms >= 1 )
      {
        mag.setVal( parsedInputLine[fieldPositions[i]+1].string_ );
        mag.setGiven( true );
      }

      if ( numTerms == 2 )
      {
        phase.setVal( parsedInputLine[fieldPositions[i]+2].string_ );
        phase.setGiven( true );
      }

      // Add magnitude and phase parameters to instanceParameters.
      device_block.addInstanceParameter( mag );
      device_block.addInstanceParameter( phase );

    }
    else if ( fieldNames[i] == "SOURCEFCN" )
    {
      // Determine the source function.
      const std::string &sourceFunction = parsedInputLine[ fieldPositions[i] ].string_;

      // Check for optional parentheses around source function parameters,
      // and set start and end position of source function parameters on
      // the input line (skip the initial parenthese).
      int sourceFunctionParamStart;
      int sourceFunctionParamEnd;

      // skip forward over nested parentheses, and omit trailing parentheses
      int frontOffset=1;
      int backOffset=1;
      while (fieldPositions[i] + frontOffset < parsedInputLine.size() &&  parsedInputLine[ fieldPositions[i] + frontOffset ].string_ == "(" )
      {
        ++frontOffset;
      }
      while ( parsedInputLine[ fieldPositions[i+1] - backOffset ].string_ == ")" )
      {
        ++backOffset;
      }

      sourceFunctionParamStart = fieldPositions[i] + frontOffset;
      sourceFunctionParamEnd = fieldPositions[i + 1] - backOffset;

      if (!equal_nocase(sourceFunction, "PWL"))
      {
        // Get the source function parameters from metadata, set their
        // values to the given input value and add to the device instance
        // parameter list.

        // Set the number of parameters for this source function on
        // the input line.
        size_t numInputSourceFunctionParams = sourceFunctionParamEnd - sourceFunctionParamStart + 1;

        // const std::vector<Param> &sourceFunctionParameters = metadata_.getSourceFunctionParameters(sourceFunction);
        const std::vector<Param> &sourceFunctionParameters = getSourceFunctionParameters(sourceFunction);
        for ( size_t k = 0; k < sourceFunctionParameters.size(); ++k )
        {
          if ( k < numInputSourceFunctionParams )
          {
            Param parameter(sourceFunctionParameters[k].uTag(), 0.0);
            parameter.setVal( parsedInputLine[sourceFunctionParamStart + k].string_ );
            parameter.setGiven( true );
            device_block.addInstanceParameter( parameter );
          }
        }
      }
      else // PWL source
      {
        if ( parsedInputLine.size() <= sourceFunctionParamStart ) 
        {
          // this test handle instance lines of the form V1 1 0 PWL, without any other source data.
          // That instance line would cause a segfault later in this IF-ELSE block.
          Report::UserError().at(device_block.getNetlistFilename(), parsedInputLine[0].lineNumber_)
            << "PWL device missing source parameters: " << device_block.getInstanceName();
          return false;         
        }
        else
        { 
          ExtendedString field(parsedInputLine[sourceFunctionParamStart].string_);
          if (field.toUpper() != "FILE")
          {
            // Xyce expects the "R" parameter to be tagged "REPEATTIME". Find
            // that parameter and rename it.
            //Param* parameterPtr = findInstanceParameter( Param("R", "") );
            //parameterPtr->setTag( "REPEATTIME" );

            // Locate the start of the (time, value) pairs in the PWL source.
            int timeValPairStart = sourceFunctionParamStart;
            while ( parsedInputLine[timeValPairStart].string_ == "R" || parsedInputLine[timeValPairStart].string_ == "TD" )
            {
              timeValPairStart += 3;
              // next if statement accounts for a missing list of time-voltage pairs.  
              // Otherwise the next iteration of the while loop will cause a seg-fault.
              if (timeValPairStart >=  parsedInputLine.size()) {break;}
            }

            // In the PWL source case, sourceFunctionParamEnd could have been
            // miscaluated if the repeat time or time delay appeared with no
            // other tagged parameters (which are required to be at the end of
            // the line. In this case recalculate teh value of
            // sourceFunctionParamEnd.
            if ( sourceFunctionParamEnd < timeValPairStart )
            {
              //sourceFunctionParamEnd = (int) parsedInputLine.size() - 1;
              sourceFunctionParamEnd = static_cast<int> (parsedInputLine.size()) - 1;
              if ( parsedInputLine[sourceFunctionParamEnd].string_ == ")" )
              {
                --sourceFunctionParamEnd;
              }
            }

            // Add (time, value) pairs to the instance parameters. Also,
            // reset the parameter ("NUM") that indicates the number of
            // such pairs and "REPEAT" which is a boolean that indicates
            // that PWL function is periodic.
            Param time( "T", "" );
            Param value( "V", "" );
            int numTimeValuePairs = 0;
            int i = timeValPairStart;
            while ( i < sourceFunctionParamEnd )
            {
              ++numTimeValuePairs;

              time.setVal( parsedInputLine[i].string_ );
              time.setGiven( true );
              device_block.addInstanceParameter( time );
              ++i;

              value.setVal( parsedInputLine[i].string_ );
              value.setGiven( true );
              device_block.addInstanceParameter( value );
              ++i;

              // HSpice compatibility, where time-value pairs are
              // separated with a comma
              if ( i < sourceFunctionParamEnd )
              {
                if ( parsedInputLine[i].string_ == "," ) ++i;
              }
            }

            if ( numTimeValuePairs > 0 )
            {
              Param * parameterPtr = device_block.findInstanceParameter( Param("NUM", "") );
              parameterPtr->setVal( numTimeValuePairs );
              parameterPtr->setGiven( true );
            }
            else
            {
              // no FILE parameter given (that's the next else block)
              // so there should have been some time, value pairs given
              // however, numTimeValueParis == 0.
              Report::UserError().at(device_block.getNetlistFilename(), parsedInputLine[0].lineNumber_)
                << "Could not parse time/value pairs for PWL function in device: " << device_block.getInstanceName();
              return false;
            }
          }
          else
          {
            std::string tvFileNameIN;
            // PWL time value pairs are given in specified file. Get the
            // file name, open and read (time, value) pairs.
            if (parsedInputLine.size() >= sourceFunctionParamStart+2)
            {
              tvFileNameIN = parsedInputLine[sourceFunctionParamStart+1].string_;
            }
            else
            {
              Report::UserError().at(device_block.getNetlistFilename(), parsedInputLine[0].lineNumber_)
                << "Could not parse FILE specification for PWL function in device: " << device_block.getInstanceName();
              return false;
            }

            // If the file name is enclosed in double quotes, strip them.
            std::string tvFileName;
            if (tvFileNameIN[0] == '"' &&
                tvFileNameIN[tvFileNameIN.length()-1] =='"')
            {
              tvFileName = tvFileNameIN.substr(1, tvFileNameIN.length()-2);
            }
            else
            {
              tvFileName = tvFileNameIN;
            }

            // Error out if the user-specified PWL specification file does not exist, cannot
            // be opened, or is a directory name rather than a file name.  See SON Bugs 730 
            // and 785 for more details.
            if ( !(Util::checkIfValidFile(tvFileName)) )
            {
              if (Util::checkIfValidURI(tvFileName))
              {
                // Lazy binding
                Param uri( "URI", tvFileName );
                device_block.addInstanceParameter(uri);
                return true;
              }
              else
              {
                Report::UserError().at(device_block.getNetlistFilename(), parsedInputLine[0].lineNumber_) 
                << "Could not find file " << tvFileName << " for PWL function in device: " << device_block.getInstanceName();
                return false;
              }
            }

            std::ifstream tvDataIn;
            tvDataIn.open(tvFileName.c_str(), std::ios::in);
            if ( !tvDataIn.is_open() )
            {
              Report::UserError().at(device_block.getNetlistFilename(), parsedInputLine[0].lineNumber_) 
                << "Could not open file " << tvFileName << " for PWL function in device: " << device_block.getInstanceName();
              return false;
            }

            Param time( "T", "" );
            Param value( "V", "" );

            int numTimeValuePairs = 0;
            double timeIn;
            double valueIn;
            while (tvDataIn >> timeIn)
            {
              char ch;
              tvDataIn.get(ch);

              if (tvDataIn >> valueIn)
              {
                ++numTimeValuePairs;

                time.setVal(timeIn);
                time.setGiven( true );
                device_block.addInstanceParameter(time);

                value.setVal(valueIn);
                value.setGiven( true );
                device_block.addInstanceParameter(value);
              }
              else
              {
                Report::UserError().at(device_block.getNetlistFilename(), parsedInputLine[0].lineNumber_)
                  << "Problem reading " << tvFileName << std::endl
                  << "File format must be comma, tab or space separated value. There should be no extra spaces or tabs "
                  << "around the comma if it is used as the separator.";
                return false;
              }
            }

            tvDataIn.close();

            if ( numTimeValuePairs > 0 )
            {
              Param* parameterPtr = device_block.findInstanceParameter( Param("NUM", "") );
              parameterPtr->setVal( numTimeValuePairs );
              parameterPtr->setGiven( true );
            }

            else
            {
              Report::UserError() << "Failed to successfully read " << tvFileName;
              return false;
            }
          }
        }
      }
    }
    else if ( fieldNames[i] == "PORT")
    {
      // The code here inserts instance parameters for port 
      Param port(fieldNames[i], "1");

      int numTerms = fieldPositions[i+1] - fieldPositions[i];

      if ( numTerms > 3 )
      {
        device_block.issueUnrecognizedParameterError(fieldNames[i]+" Too Many Terms");
      }


      int linePosition = fieldPositions[i] + 1;

      if ( parsedInputLine[linePosition].string_ == "=" )
      {
        ++linePosition; // if field is "=", advance to next field
      }

      port.setVal( parsedInputLine[linePosition].string_ );
      port.setGiven( true );

      // Add port parameters to instanceParameters.
      device_block.addInstanceParameter( port );
    }
    else if ( fieldNames[i] == "Z0")
    {
      // The code here inserts instance parameters for Z0 
      Param Z0(fieldNames[i], "50");

      int numTerms = fieldPositions[i+1] - fieldPositions[i];

      if ( numTerms > 3 )
      {
        device_block.issueUnrecognizedParameterError(fieldNames[i]+" Too Many Terms");
      }
      int linePosition = fieldPositions[i] + 1;

      if ( parsedInputLine[linePosition].string_ == "=" )
      {
        ++linePosition; // if field is "=", advance to next field
      }

      Z0.setVal( parsedInputLine[linePosition].string_ );
      Z0.setGiven( true );

      // Add Z0 parameters to instanceParameters.
      device_block.addInstanceParameter( Z0 );
    }  
  }

  return true; // Only get here on success.
}

} // namespace Device
} // namespace Xyce
src/DeviceModelPKG/Core/N_DEV_SourceData.h0000644000175000017500000004276613660205157016545 0ustar  dkcdkc//-------------------------------------------------------------------------
//   Copyright 2002-2020 National Technology & Engineering Solutions of
//   Sandia, LLC (NTESS).  Under the terms of Contract DE-NA0003525 with
//   NTESS, the U.S. Government retains certain rights in this software.
//
//   This file is part of the Xyce(TM) Parallel Electrical Simulator.
//
//   Xyce(TM) 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 3 of the License, or
//   (at your option) any later version.
//
//   Xyce(TM) 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 Xyce(TM).
//   If not, see <http://www.gnu.org/licenses/>.
//-------------------------------------------------------------------------

//-----------------------------------------------------------------------------
//
// Purpose        : Source data containers.  Used by the vsrc and isrc
//                  devices.
//
// Special Notes  :
//
// Creator        : Eric R. Keiter, SNL, Parallel Computational Sciences
//
// Creation Date  : 02/28/00
//
//
//
//
//-----------------------------------------------------------------------------

#ifndef Xyce_N_DEV_SourceData_h
#define Xyce_N_DEV_SourceData_h

// ---------- Standard Includes ----------
#include <vector>
#include <list>
#include <dlfcn.h>

// ----------   Xyce Includes   ----------
#include <N_IO_fwd.h>
#include <N_UTL_fwd.h>

#include <N_DEV_Device.h>
#include <N_DEV_DeviceBlock.h>
#include <N_DEV_Param.h>

enum Src_mod {
  _STATIC_SRC   = 0,  
  _DYNAMIC_SRC  = 0x10
};
    
enum Src_index {
  _SIN_DATA,
  _EXP_DATA,
  _PULSE_DATA,
  _PWL_DATA,
  _PAT_DATA,
  _SFFM_DATA,
  _DC_DATA,
  _AC_DATA,
  _PORT_DATA,
  _NUM_SRC_DATA
};


namespace Xyce {
namespace Device {

#define  EXT_CLASSES 
#include <N_DEV_SourceDataExt.h>

typedef std::map<std::string, std::vector<Param>, LessNoCase> DeviceParamMap;

void sourceFunctionMetadata(DeviceParamMap &map);
int getSourceFunctionID(const std::string & sourceFcn);
const std::vector<Param> &getSourceFunctionParameters(const std::string &sourceFcn);

//-----------------------------------------------------------------------------
// Class         : SourceData
// Purpose       :
// Special Notes :
// Creator       : Eric Keiter
// Creation Date : 4/24/00
//-----------------------------------------------------------------------------

class SourceData
{
  friend class VsrcModel;
  friend class VsrcInstance;
  friend class ISRCModel;
  friend class ISRCInstance;
  friend class SourceInstance;

public:
  SourceData(const SolverState & ss1, const DeviceOptions & do1);

private:
  SourceData(const SourceData &right);
  SourceData &operator=(const SourceData &right);

public:
  virtual ~SourceData();

  virtual bool initializeSource ();

  virtual bool updateSource() = 0;

  virtual void setupBreakpoints() {return;}
  virtual bool getBreakPoints (std::vector<Util::BreakPoint> & breakPointTimes)
  { return true; }

  virtual double getMaxTimeStepSize ();

  virtual void setRealFlag(bool flag) { realFlag_ = true;}

  virtual double period() { return 0.0; }

  double returnSource ();

  bool getResetFlag ()
  {
    return resetFlag_;
  }

  std::string getSourceTypeName ();

  virtual void getParams (double *) {}
  virtual void setParams (double *) {}
  virtual void printOutParams();

  bool getFastTimeScaleFlag() const
  {
    return fastTimeScaleFlag_;
  }

  void setFastTimeScaleFlag(bool fastTimeScaleFlag)
  {
    fastTimeScaleFlag_ = fastTimeScaleFlag;
  }

  double getTime_() const;

private:
  SourceData ();

protected:
  std::string sourceName_;
  std::string typeName_;
  std::string defaultParamName_;

  double time;
  double SourceValue;

  bool initializeFlag_;

  bool resetFlag_;

  const SolverState & solState_;
  const DeviceOptions & devOptions_;

  bool fastTimeScaleFlag_;

  bool realFlag_;
};

//-----------------------------------------------------------------------------
// Class         : SinData
// Purpose       : This class contains data and functions associated with
//                 sinusoidal independent sources.
// Special Notes :
// Creator       : Eric Keiter
// Creation Date : 3/16/00
//-----------------------------------------------------------------------------

class SinData : public SourceData
{

public:
  SinData(
    const DeviceEntity &        device,
    const std::vector<Param> &  paramRef,
    const SolverState   &       ss1,
    const DeviceOptions &       do1);

  ~SinData();

private:
  SinData(const SinData &right);
  SinData &operator=(const SinData &right);

public:
  bool initializeSource ();
  virtual bool updateSource() /* override */ ;
  void getParams (double *);
  void setParams (double *);

  void printOutParams();

  double getMaxTimeStepSize () { return (0.1/FREQ); }

  double period() { return (1.0/FREQ); }

private:
  // Data Members for Class Attributes

  double V0;    // Offset (V or A)
  double VA;    // Amplitude (V or A)
  double FREQ;  // Frequency (Hz)
  double TD;    // Delay (seconds)
  double THETA; // Damping factor (1/seconds)
  double PHASE; // Phase (degrees)

  bool   V0given;
  bool   VAgiven;
  bool   FREQgiven;
  bool   TDgiven;
  bool   THETAgiven;
  bool   PHASEgiven;

  friend class VsrcModel;
  friend class VsrcInstance;
  friend class ISRCModel;
  friend class ISRCInstance;
};

//-----------------------------------------------------------------------------
// Class         : ExpData
// Purpose       : This class contains data and functions associated with
//                 exponential independent sources.
// Special Notes :
// Creator       : Eric Keiter
// Creation Date : 3/16/00
//-----------------------------------------------------------------------------
class ExpData : public SourceData
{
  friend class VsrcModel;
  friend class VsrcInstance;
  friend class ISRCModel;
  friend class ISRCInstance;

public:
  ExpData(const DeviceEntity & device, const std::vector<Param> & paramRef,
          const SolverState & ss1,
          const DeviceOptions & do1);

  ~ExpData();

private:
  ExpData(const ExpData & right);
  ExpData &operator=(const ExpData & right);

public:
  bool initializeSource ();
  virtual bool updateSource() /* override */ ;
  void getParams (double *);
  void setParams (double *);

  void printOutParams ();

private:
  double V1;   // Initial value (V or A)
  double V2;   // Pulsed value (V or A).
  double TD1;  // Rise delay time (seconds).
  double TAU1; // Rise time constant (seconds)
  double TD2;  // Fall delay time (seconds).
  double TAU2; // Fall time constant (seconds)

  bool  V1given;
  bool  V2given;
  bool  TD1given;
  bool  TAU1given;
  bool  TD2given;
  bool  TAU2given;
};


//-----------------------------------------------------------------------------
// Class         : ACData
// Purpose       : This class contains data and functions associated with
//                 AC independent sources.
// Special Notes :
// Creator       : Ting Mei
// Creation Date :
//-----------------------------------------------------------------------------

class ACData : public SourceData
{
  friend class VsrcModel;
  friend class VsrcInstance;
  friend class ISRCModel;
  friend class ISRCInstance;

public:
  ACData(const DeviceEntity & device, const std::vector<Param> & paramRef,
         const SolverState   & ss1,
         const DeviceOptions & do1);

  ~ACData();

private:
  ACData(const ACData &right);
  ACData &operator=(const ACData &right);

public:
  virtual bool updateSource() /* override */ ;
  void getParams (double *);
  void setParams (double *);

  void printOutParams();

  void setRealFlag(bool flag) { realFlag_ = flag; }

private:
  double ACMAG;    // Amplitude (V or A)
  double ACPHASE; // Phase (degrees)

  bool ACMAGgiven;
  bool ACPHASEgiven;
};


//-----------------------------------------------------------------------------
// Class         : PulseData
// Purpose       : This class contains data and functions associated with
//                 pulsed independent sources.
// Special Notes :
// Creator       : Eric Keiter
// Creation Date : 3/16/00
//-----------------------------------------------------------------------------
class PulseData : public SourceData
{
  friend class VsrcModel;
  friend class VsrcInstance;
  friend class ISRCModel;
  friend class ISRCInstance;

public:
  PulseData(const DeviceEntity & device, const std::vector<Param> & paramRef,
            const SolverState   & ss1,
            const DeviceOptions & do1);

  ~PulseData();

private:
  PulseData(const PulseData  & right);
  PulseData &operator=(const PulseData  & right);

public:
  bool initializeSource();
  virtual bool updateSource() /* override */ ;
  void getParams (double *);
  void setParams (double *);
  bool getBreakPoints(std::vector<Util::BreakPoint> & breakPointTimes);

  void printOutParams();

  double getMaxTimeStepSize ();

  double period() { return PER; }

public:
  double V1;  // Initial value  (for a voltage source, units are Volts,
  // For a current source, units are Amps)
  double V2;  // Pulsed value. (Volts or Amps)
  double TD;  // Delay time  (seconds)
  double TR;  // Rise time (seconds)
  double TF;  // Fall Time  (seconds)
  double PW;  // Pulse Width (seconds)
  double PER; // Period (seconds)

  bool V1given;
  bool V2given;
  bool TDgiven;
  bool TRgiven;
  bool TFgiven;
  bool PWgiven;
  bool PERgiven;
};


//-----------------------------------------------------------------------------
// Class         : PWLinData
// Purpose       : This class contains the data and functions associated
//                 with piece-wise linear independent sources.
// Special Notes :
// Creator       : Eric Keiter
// Creation Date : 3/16/00
//-----------------------------------------------------------------------------
class PWLinData : public SourceData
{
  friend class VsrcModel;
  friend class VsrcInstance;
  friend class ISRCModel;
  friend class ISRCInstance;
  friend class PWLinDynData;

public:
  PWLinData(const DeviceEntity & device, const std::vector<Param> & paramRef,
            const SolverState   & ss1,
            const DeviceOptions & do1,
            const std::string   & t_name = "PWL");

  ~PWLinData();

private:
  PWLinData(const PWLinData &right);
  PWLinData &operator=(const PWLinData &right);

public:
  virtual bool updateSource() /* override */ ;
  virtual void setupBreakpoints() { preComputedBreakpointsDone = false; }
  virtual bool getBreakPoints( std::vector<Util::BreakPoint> & breakPointTimes);
  void printOutParams ();

private:
  // Data Members for Class Attributes
  int NUM; //number of time,voltage pairs
  bool REPEAT; //repeat cycle?
  double REPEATTIME; //start time in cycle for repeat
  double TD; //time delay
  std::vector< std::pair<double,double> > TVVEC;  // Array (time,voltage)

  int loc_; //current location in time vector
  double starttime_; //absolute start time of current cycle


  bool preComputedBreakpointsDone;
};

//-----------------------------------------------------------------------------
// Class         : PWLinDynData
// Purpose       : This class contains the data and functions associated
//                 with piece-wise linear independent sources from a URI
// Special Notes : Handles like a rehgular PWL source other than how data
//                 is acquired.
// Creator       : Kevin Cameron
// Creation Date : 4/28/20
//-----------------------------------------------------------------------------
class PWLinDynData : public PWLinData
{
 public:
  PWLinDynData(const DeviceEntity  & device, const std::vector<Param> & paramRef,
               const SolverState   & ss1,
               const DeviceOptions & do1);

  ~PWLinDynData();

  virtual bool updateSource();
  virtual bool getBreakPoints( std::vector<Util::BreakPoint> & breakPointTimes);
  
  enum BridgeOP {
# define BRIDGE_OP(o) o,
# include "N_DEV_BridgeOp.inc"
      NoOp
  };
  typedef int (*Callback)(PWLinDynData *,void *ext_data, BridgeOP op, void *op_data); // returns zero if OK

private:

  Callback BridgeFn;
  void    *BridgeFnData;
  double   next_bp;

  Callback BindCB(const char *lib_name,const char *fn_name,const char *args,void **data);

public:
  inline int CallBridge(BridgeOP op,void *data = NULL) { return (*BridgeFn)(this,BridgeFnData,op,data); }

  inline tTVVEC *getTVVEC() { return &TVVEC; }

  inline void RecalculateBreaks() { preComputedBreakpointsDone = false; }
  inline void ResetNUM()          { NUM = TVVEC.size(); RecalculateBreaks(); }

  inline int addBreak (double bp) { next_bp = bp; }

  inline c_string getSrcName()  { return sourceName_.c_str(); }
  inline c_string getTypName()  { return typeName_.c_str(); }
  inline c_string getPrmName()  { return defaultParamName_.c_str(); }
};

//-----------------------------------------------------------------------------
// Class         : PatData
// Purpose       : This class contains the data and functions associated
//                 with the Pattern independent sources.
// Special Notes :
// Creator       : Pete Sholander
// Creation Date : 3/18/19
//-----------------------------------------------------------------------------
class PatData : public SourceData
{
  friend class VsrcModel;
  friend class VsrcInstance;
  friend class ISRCModel;
  friend class ISRCInstance;

public:
  PatData(const DeviceEntity & device, const std::vector<Param> & paramRef,
            const SolverState   & ss1,
            const DeviceOptions & do1);

  ~PatData();

private:
  PatData(const PatData &right);
  PatData &operator=(const PatData &right);

public:
  virtual bool updateSource() /* override */ ;
  void getParams (double *);
  void setParams (double *);
  void updateTVVEC();

  bool getBreakPoints( std::vector<Util::BreakPoint> & breakPointTimes);

  void printOutParams ();

private:
  // Data Members for Class Attributes
  double VHI;        // high voltage (or current) value
  double VLO;        // low voltage (or current) value
  double TD;         // time delay
  double TR;         // rise time
  double TF;         // fall time
  double TSAMPLE;    // bit period
  std::string DATA;  // bit pattern (as a string)
  int  RB;           // starting bit (in pattern) when repeating
  int  R;            // number of times pattern repeats
  double PATREPEATTIME; // Time at which the pattern repeats
  std::vector< std::pair<double,double> > TVVEC;  // Array (time,voltage)

  bool VHIgiven;
  bool VLOgiven;
  bool TDgiven;
  bool TRgiven;
  bool TFgiven;
  bool TSAMPLEgiven;
  bool DATAgiven;  

  int NUMDATA;           // number of values in string DATA
  int NUMBP;             // number of breakpoints generated from DATA string
  int loc_; //current location in time vector
  double starttime_; //absolute start time of current cycle
};


//-----------------------------------------------------------------------------
// Class         : SFFMData
// Purpose       : This class contains data and functions associated with
//                 Single-frequency FM independent sources.
// Special Notes :
// Creator       : Eric Keiter
// Creation Date : 3/16/00
//-----------------------------------------------------------------------------
class SFFMData : public SourceData
{
  friend class VsrcModel;
  friend class VsrcInstance;
  friend class ISRCModel;
  friend class ISRCInstance;

public:
  SFFMData(const DeviceEntity & device, const std::vector<Param> & paramRef,
           const SolverState   & ss1,
           const DeviceOptions & do1);

  ~SFFMData();

private:
  SFFMData(const SFFMData   & right);
  SFFMData &operator=(const SFFMData   & right);

public:
  bool initializeSource ();
  virtual bool updateSource() /* override */ ;
  void getParams (double *);
  void setParams (double *);

  void printOutParams ();

private:
  double V0;  // Offset. (V or A)
  double VA;  // Amplitude (V or A)
  double FC;  // Carrier frequency (Hz)
  double MDI; // Modulation index
  double FS;  // Signal frequency (Hz)

  bool V0given;
  bool VAgiven;
  bool FCgiven;
  bool MDIgiven;
  bool FSgiven;
};

//-----------------------------------------------------------------------------
// Class         : ConstData
// Purpose       : This class contains data and functions associated with
//                 const DC sources.  It is not yet implemented.
// Special Notes :
// Creator       : Robert Hoekstra
// Creation Date : 10/4/00
//-----------------------------------------------------------------------------
class ConstData : public SourceData
{
  friend class VsrcModel;
  friend class VsrcInstance;
  friend class ISRCModel;
  friend class ISRCInstance;

public:
  ConstData(const DeviceEntity & device, const std::vector<Param> & paramRef,
            const SolverState   & ss1,
            const DeviceOptions & do1);

  ~ConstData();

private:
  ConstData(const ConstData   & right);
  ConstData &operator=(const ConstData   & right);

public:
  virtual bool updateSource() /* override */ ;
  void getParams (double *);
  void setParams (double *);

  void printOutParams();

private:
  double V0;
};

bool extractSourceData(
  const IO::TokenVector &               parsedInputLine,
  IO::DeviceBlock &                     device_block,
  const std::string &                   primaryDeviceParameter);

bool extractSourceFields(
  const IO::TokenVector &               parsedInputLine,
  IO::DeviceBlock &                     device_block,
  const std::vector<std::string> &      fieldNames,
  const std::vector<int> &              fieldPositions);

} // namespace Device
} // namespace Xyce

#endif
src/DeviceModelPKG/Core/N_DEV_SourceDataExt.h0000666000175000017500000000060113654372532017215 0ustar  dkcdkc#include <vector>

// for inclusion in non-Xyce code to get some type-checking

class PWLinDynData;
class DeviceInstance;

using namespace std;

extern "C" {
typedef std::vector< std::pair<double,double> > tTVVEC;  // Array (time,voltage)
typedef const char *c_string;

#ifdef NEED_FN_DECL
#define FN_DECL(ret,nm,argt,arg) ret nm argt;
#include "N_DEV_SourceDataExt.inc"
#endif
    
}
src/DeviceModelPKG/Core/N_DEV_SourceDataExt.inc0000666000175000017500000000163313660205157017540 0ustar  dkcdkcFN_DECL(tTVVEC*,  DeviceGetTVVEC,      (PWLinDynData *dev), (dev))
FN_DECL(double,   DeviceGetTime,       (PWLinDynData *dev), (dev))
FN_DECL(void,     DeviceResetNUM,      (PWLinDynData *dev), (dev))
FN_DECL(void,     DeviceRedoBreaks,    (PWLinDynData *dev), (dev))
FN_DECL(c_string, DeviceGetSrcName,    (PWLinDynData *dev), (dev))
FN_DECL(c_string, DeviceGetTypName,    (PWLinDynData *dev), (dev))
FN_DECL(c_string, DeviceGetPrmName,    (PWLinDynData *dev), (dev))

FN_DECL(int,      DevAddBreak,   (PWLinDynData *dev, double  bp),   (dev,bp))

FN_DECL(double,   DeviceGetParam,      (DeviceInstance *inst,c_string name,double dflt), (inst,name,dflt))
FN_DECL(c_string, InstanceGetName,     (DeviceInstance *inst), (inst))
FN_DECL(int,      InstanceGetVsrcV,    (DeviceInstance *inst, double *pRet), (inst,pRet))
FN_DECL(int,      InstanceGetIsrcV,    (DeviceInstance *inst, double *pRet), (inst,pRet))

#undef FN_DECL
src/DeviceModelPKG/OpenModels/0000777000175000017500000000000013660205157014531 5ustar  dkcdkcsrc/DeviceModelPKG/OpenModels/N_DEV_ISRC.C0000644000175000017500000006364713660205157016364 0ustar  dkcdkc//-------------------------------------------------------------------------
//   Copyright 2002-2020 National Technology & Engineering Solutions of
//   Sandia, LLC (NTESS).  Under the terms of Contract DE-NA0003525 with
//   NTESS, the U.S. Government retains certain rights in this software.
//
//   This file is part of the Xyce(TM) Parallel Electrical Simulator.
//
//   Xyce(TM) 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 3 of the License, or
//   (at your option) any later version.
//
//   Xyce(TM) 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 Xyce(TM).
//   If not, see <http://www.gnu.org/licenses/>.
//-------------------------------------------------------------------------

//-------------------------------------------------------------------------
//
// Purpose        : Independent current source
//
// Special Notes  :
//
// Creator        : Eric R. Keiter, SNL, Parallel Computational Sciences
//
// Creation Date  : 02/28/00
//
//
//
//
//-------------------------------------------------------------------------

#include <Xyce_config.h>


// ---------- Standard Includes ----------

// ----------   Xyce Includes   ----------
#include <N_DEV_DeviceMgr.h>
#include <N_DEV_DeviceOptions.h>
#include <N_DEV_ExternData.h>
#include <N_DEV_ISRC.h>
#include <N_DEV_MatrixLoadData.h>
#include <N_DEV_SolverState.h>
#include <N_DEV_SourceData.h>
#include <N_DEV_Message.h>
#include <N_ERH_ErrorMgr.h>
#include <N_UTL_BreakPoint.h>

#include <N_LAS_Vector.h>
#include <N_LAS_Matrix.h>
#include <N_UTL_FeatureTest.h>

namespace Xyce {
namespace Device {
namespace ISRC {

void Traits::loadInstanceParameters(ParametricData<ISRC::Instance> &p)
{
  // DC parameters
  p.addPar ("DCV0", 0.0, &ISRC::Instance::DCV0)
    .setOriginalValueStored(true)
    .setUnit(U_VOLT)
    .setDescription("DC Current");

  // Pulse parameters
  p.addPar ("V0", 0.0, &ISRC::Instance::par0)
    .setUnit(U_AMP)
    .setDescription("Offset Current");

  p.addPar ("V1", 0.0, &ISRC::Instance::par0)
    .setUnit(U_AMP)
    .setDescription("Initial Current");

  p.addPar ("V2", 0.0, &ISRC::Instance::par1)
    .setUnit(U_AMP)
    .setDescription("Pulsed Current");

  p.addPar ("TD", 0.0, &ISRC::Instance::par2)
    .setUnit(U_SECOND)
    .setDescription("Delay");

  p.addPar ("TR", 0.0, &ISRC::Instance::par3)
    .setUnit(U_SECOND)
    .setDescription("Rise Time");

  p.addPar ("TF", 0.0, &ISRC::Instance::par4)
    .setUnit(U_SECOND)
    .setDescription("Fall Time");

  p.addPar ("PW", 0.0, &ISRC::Instance::par5)
    .setUnit(U_SECOND)
    .setDescription("Pulse Width");

  p.addPar ("PER", 0.0, &ISRC::Instance::par6)
    .setUnit(U_SECOND)
    .setDescription("Period");

  // Sin parameters
  p.addPar ("VA", 0.0, &ISRC::Instance::par1)
    .setUnit(U_AMP)
    .setDescription("Amplitude");

  p.addPar ("FREQ", 0.0, &ISRC::Instance::par3)
    .setUnit(U_SECM1)
    .setDescription("Frequency");

  p.addPar ("THETA", 0.0, &ISRC::Instance::par4)
    .setDescription("Theta");

  p.addPar ("PHASE", 0.0, &ISRC::Instance::par5)
    .setDescription("Phase");

  // Exp parameters
  p.addPar ("TD1", 0.0, &ISRC::Instance::par2)
    .setUnit(U_SECOND)
    .setDescription("Rise Delay Time");

  p.addPar ("TAU1", 0.0, &ISRC::Instance::par3)
    .setUnit(U_SECOND)
    .setDescription("Rise Time Constant");

  p.addPar ("TD2", 0.0, &ISRC::Instance::par4)
    .setUnit(U_SECOND)
    .setDescription("Fall Delay Time");

  p.addPar ("TAU2", 0.0, &ISRC::Instance::par5)
    .setUnit(U_SECOND)
    .setDescription("Fall Time Constant");

  // AC parameters
  p.addPar ("ACMAG", 0.0, &ISRC::Instance::ACMAG)
    .setUnit(U_VOLT)
    .setDescription("Amplitude");

  p.addPar ("ACPHASE", 0.0, &ISRC::Instance::ACPHASE)
    .setDescription("Phase");

  // SFFM parameters
  p.addPar ("FC", 0.0, &ISRC::Instance::par2)
    .setUnit(U_SECM1)
    .setDescription("Carrier Frequency");

  p.addPar ("FS", 0.0, &ISRC::Instance::par4)
    .setUnit(U_SECM1)
    .setDescription("Signal Frequency");

  p.addPar ("MDI", 0.0, &ISRC::Instance::par3)
    .setDescription("Modulation Index");

  // PWL params
  p.addPar ("R", 0.0, &ISRC::Instance::REPEATTIME)
    .setUnit(U_SECOND)
    .setDescription("Repeat Time");

  p.addPar ("T", 0.0, &ISRC::Instance::T)
    .setUnit(U_SECOND)
    .setDescription("Time");  // time-voltage pairs

  p.addPar ("V", 0.0, &ISRC::Instance::V)
    .setUnit(U_AMP)
    .setDescription("Current"); // time-voltage pairs

  // PAT params
  p.addPar ("VHI", 0.0, &ISRC::Instance::par0)
   .setUnit(U_VOLT)
   .setCategory(CAT_NONE)
   .setDescription("High Voltage Value");

  p.addPar ("VLO", 0.0, &ISRC::Instance::par1)
   .setUnit(U_VOLT)
   .setCategory(CAT_NONE)
   .setDescription("Low Voltage Value");

  p.addPar ("TSAMPLE", 0.0, &ISRC::Instance::par5)
   .setUnit(U_SECOND)
   .setCategory(CAT_NONE)
   .setDescription("Pulse Width");

  p.addPar ("DATA", "", &ISRC::Instance::DATA)
   .setUnit(U_NONE)
   .setCategory(CAT_NONE)
   .setDescription("Data Pattern");

  p.addPar ("RB", 1, &ISRC::Instance::RB)
   .setUnit(U_NONE)
   .setCategory(CAT_NONE)
   .setDescription("Starting Bit When Repeating");

  // Set up non-double precision variables:
  p.addPar ("TRANSIENTSOURCETYPE", (int)_DC_DATA, &ISRC::Instance::TRANSIENTSOURCETYPE)
    .setGivenMember(&ISRC::Instance::TRANSIENTSOURCETYPEgiven);

  p.addPar ("ACSOURCETYPE", (int) _AC_DATA, &ISRC::Instance::ACSOURCETYPE)
    .setGivenMember(&ISRC::Instance::ACSOURCETYPEgiven);

  p.addPar ("DCSOURCETYPE", (int) _DC_DATA, &ISRC::Instance::DCSOURCETYPE)
    .setGivenMember(&ISRC::Instance::DCSOURCETYPEgiven);

  p.addPar ("NUM", 0, &ISRC::Instance::NUM);
}

void Traits::loadModelParameters(ParametricData<ISRC::Model> &p)
{
}


std::vector< std::vector<int> > Instance::jacStamp;
std::vector< std::vector<int> > Instance::jacStampPDE;

//-----------------------------------------------------------------------------
// Function      : Instance::Instance
// Purpose       : instance block constructor
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 04/06/00
//-----------------------------------------------------------------------------
Instance::Instance(
  const Configuration & configuration,
  const InstanceBlock & instance_block,
  Model &               model,
  const FactoryBlock &  factory_block)
  : SourceInstance(instance_block, configuration.getInstanceParameters(), factory_block),
    model_(model),
    li_Pos(-1),
    li_Neg(-1),
    li_branch_data(0),
    HBSpecified_(factory_block.deviceManager_.getHBSpecified()),
    ACSpecified_(factory_block.deviceManager_.getACSpecified()),
    DCV0(0.0),
    par0(0.0),
    par1(0.0),
    par2(0.0),
    par3(0.0),
    par4(0.0),
    par5(0.0),
    par6(0.0),
    REPEATTIME(),
    T(0.0),
    V(0.0),
    DATA(""),
    RB(1),
    NUM(0),
    REPEAT(false),
    TRANSIENTSOURCETYPE(_DC_DATA),
    TRANSIENTSOURCETYPEgiven(false),
    ACSOURCETYPE(_AC_DATA),
    ACSOURCETYPEgiven(false),
    DCSOURCETYPE(_AC_DATA),
    DCSOURCETYPEgiven(false),
    gotParams(false),
    ACMAG(1.0),
    ACPHASE(0.0)
{
  numIntVars = 0;
  numExtVars = 2;
  numStateVars = 0;
  setNumBranchDataVars(0);             // by default don't allocate space in branch vectors
  numBranchDataVarsIfAllocated = 1;    // this is the space to allocate if lead current or power is needed.

  if( jacStamp.empty() )
  {
    jacStamp.resize(2);

    // PDE supporting stamp.  This includes diagonal elements, needed by the
    // 2-level Newton.
    jacStampPDE.resize(2);
    jacStampPDE[0].resize(1);
    jacStampPDE[1].resize(1);
    jacStampPDE[0][0] = 0;
    jacStampPDE[1][0] = 1;
  }

  // Set params to constant default values:
  setDefaultParams ();

  // Set params according to instance line and constant defaults from metadata:
  Src_mod mods = setParams (instance_block.params);

  const SolverState &solver_state = factory_block.solverState_;
  const DeviceOptions &device_options = factory_block.deviceOptions_;

  // Set any non-constant parameter defaults:
  if (ACSpecified_ && ACSOURCETYPEgiven)
  {
    acSourceData_ = new ACData(*this, instance_block.params, solver_state, device_options);
  }


  dcSourceData_ = new ConstData(*this, instance_block.params, solver_state, device_options);

  if (HBSpecified_ || TRANSIENTSOURCETYPEgiven)
  {
    switch (TRANSIENTSOURCETYPE|mods)        
    {
      case _SIN_DATA:
        tranSourceData_ = new SinData(*this, instance_block.params, solver_state, device_options);
        break;

      case _EXP_DATA:
        tranSourceData_ = new ExpData(*this, instance_block.params, solver_state, device_options);
        break;

      case _PULSE_DATA:
        tranSourceData_ = new PulseData(*this, instance_block.params, solver_state, device_options);
        break;

      case _PWL_DATA:
        tranSourceData_ = new PWLinData(*this, instance_block.params, solver_state, device_options);
        break;

      case _PWL_DATA | _DYNAMIC_SRC: {
        PWLinDynData *src = new PWLinDynData(*this, instance_block.params, solver_state, device_options);
        tranSourceData_ = src;
        if (src->CallBridge(PWLinDynData::Init,this) < 0) { // initialize bridge
            UserFatal(*this) << "Failed to connect URI " << getName();
        }
      } break;

      case _PAT_DATA:
        tranSourceData_ = new PatData(*this, instance_block.params, solver_state, device_options);
        break;

      case _SFFM_DATA:
        tranSourceData_ = new SFFMData(*this, instance_block.params, solver_state, device_options);
        break;

      case _DC_DATA:
        tranSourceData_ = 0; // this forces us to use the DC source pointer
        break;

      default:
        UserError(*this) << "Cannot identify source data type for " << getName();
        break;
    }
  }

  processParams();

  // Calculate any parameters specified as expressions:

  updateDependentParameters();
  processParams();
}

extern "C" {

int InstanceGetIsrcV(DeviceInstance *dev_inst,double *ret) {
    Instance          *inst     = (Instance *)dev_inst;
    const SolverState *ss       = inst->solState();
    const ExternData  *extDataP = inst->extDataPtr();
    double            *lVec     = extDataP->lastSolVectorRawPtr;
    double            *nVec     = extDataP->nextSolVectorRawPtr;
    double            *cVec     = extDataP->currSolVectorRawPtr;
    int               sts       = 0;
    ret[3] = (ret[0] = ss->currTime_)
                     + ss->currTimeStep_;
    if (cVec) {
        ret[1] = cVec[inst->liPos()];
        ret[2] = cVec[inst->liNeg()];
        ret[4] = nVec[inst->liPos()];
        ret[5] = nVec[inst->liNeg()];
        sts   |= 3;
    } else {
        ret[1] = nVec[inst->liPos()];
        ret[2] = nVec[inst->liNeg()];
        sts   |= 1;
    }
    return sts;
}
    
}

//-----------------------------------------------------------------------------
// Function      : Instance::processParams
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 04/06/00
//-----------------------------------------------------------------------------
bool Instance::processParams ()
{
  if (gotParams)
  {
    if (dcSourceData_ != 0)
    {
      dcSourceData_->setParams (&DCV0);
    }
    if (acSourceData_ != 0)
    {
      acSourceData_->setParams (&ACMAG);
    }
    if (tranSourceData_ != 0)
    {
      tranSourceData_->setParams(&par0);
    }
  }
  else
  {
    if (dcSourceData_ != 0)
    {
      dcSourceData_->getParams (&DCV0);
    }
    if (acSourceData_ != 0)
    {
      acSourceData_->getParams (&ACMAG);
    }
    if (tranSourceData_ != 0)
    {
      tranSourceData_->getParams(&par0);
    }
    gotParams = true;
  }

  return true;
}

//-----------------------------------------------------------------------------
// Function      : Instance::~Instance
// Purpose       : destructor
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 04/06/00
//-----------------------------------------------------------------------------
Instance::~Instance ()
{
  delete tranSourceData_;
  delete acSourceData_;
  delete dcSourceData_;
}

// additional Declarations
//-----------------------------------------------------------------------------
// Function      : Instance::registerLIDs
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Robert Hoekstra, SNL, Parallel Computational Sciences
// Creation Date : 6/20/02
//-----------------------------------------------------------------------------
void Instance::registerLIDs( const std::vector<int> & intLIDVecRef,
	                               const std::vector<int> & extLIDVecRef)
{
  AssertLIDs(intLIDVecRef.size() == numIntVars);
  AssertLIDs(extLIDVecRef.size() == numExtVars);

  if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) )
  {
    Xyce::dout() << std::endl << section_divider << std::endl;
    Xyce::dout() << "  ISRCInstance::registerLIDs" << std::endl;
    Xyce::dout() << "  name = " << getName() << std::endl;
  }

  intLIDVec = intLIDVecRef;
  extLIDVec = extLIDVecRef;

  // Now use these lists to obtain the indices into the
  // linear algebra entities.  This assumes an order.    Note that
  // for a current  source, there  will be no Jacobian entries.

  li_Pos = extLIDVec[0];
  li_Neg = extLIDVec[1];

  if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) )
  {
    Xyce::dout() << "  li_Pos = " << li_Pos << std::endl;
    Xyce::dout() << "  li_Neg = " << li_Neg << std::endl;
    Xyce::dout() << section_divider << std::endl;
  }

}

//-----------------------------------------------------------------------------
// Function      : Instance::registerStateLIDs
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Robert Hoekstra, SNL, Parallel Computational Sciences
// Creation Date : 6/20/02
//-----------------------------------------------------------------------------
void Instance::registerStateLIDs(const std::vector<int> & staLIDVecRef )
{
  AssertLIDs(staLIDVecRef.size() == numStateVars);
}

//-----------------------------------------------------------------------------
// Function      : Instance::registerStoreLIDs
// Purpose       : One store var for device current.
// Special Notes :
// Scope         : public
// Creator       : Richard Schiek, Electrical Systems Modeling
// Creation Date : 03/27/2013
//-----------------------------------------------------------------------------
void Instance::registerStoreLIDs(const std::vector<int> & stoLIDVecRef )
{
}

//-----------------------------------------------------------------------------
// Function      : Instance::registerBranchDataLIDs
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Richard Schiek, Electrical Systems Modeling
// Creation Date : 12/18/2012
//-----------------------------------------------------------------------------
/// Register the local store IDs
///
/// In addition to state vector, Xyce maintains a separate datastructure
/// called a "branch data" vector.  As with other such vectors, the device
/// declares at construction time how many branch vector entries it needs,
/// and later Topology assigns locations for devices, returning LIDs.
///
/// These LIDs are stored in this method for later use.
///
/// The Resistor device uses exactly one "branch data vector" element, where
///
/// @param stoLIDVecRef Store variable local IDs
///
/// @author Richard Schiek, Electrical Systems Modeling
/// @date   12/18/2012

void Instance::registerBranchDataLIDs(const std::vector<int> & branchLIDVecRef)
{
  AssertLIDs(branchLIDVecRef.size() == getNumBranchDataVars());

  if (loadLeadCurrent)
  {
    li_branch_data= branchLIDVecRef[0];
  }
}

//-----------------------------------------------------------------------------
// Function      : Instance::loadNodeSymbols
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric R. Keiter, SNL, Parallel Computational Sciences
// Creation Date : 05/13/05
//-----------------------------------------------------------------------------
void Instance::loadNodeSymbols(Util::SymbolTable &symbol_table) const
{
  if (loadLeadCurrent)
  {
    addBranchDataNode( symbol_table, li_branch_data, getName(), "BRANCH_D");
  }
}


//-----------------------------------------------------------------------------
// Function      : Instance::jacobianStamp
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Robert Hoekstra, SNL, Parallel Computational Sciences
// Creation Date : 9/5/2
//-----------------------------------------------------------------------------
const std::vector< std::vector<int> > & Instance::jacobianStamp() const
{
  if (getSolverState().isPDESystem_)
    return jacStampPDE;

  return jacStamp;
}

//-----------------------------------------------------------------------------
// Function      : Instance::loadBVectorsforAC
//
// Purpose       : Loads the B-vector contributions for a single
//                 isrc instance.
//
// Special Notes :
//
// Scope         : public
// Creator       : Ting Mei, SNL
// Creation Date : 5/11
//-----------------------------------------------------------------------------
bool Instance::loadBVectorsforAC(double * bVecReal, double * bVecImag )
{
  if (acSourceData_ != 0)
  {
    acSourceData_->setRealFlag(true);

    acSourceData_->updateSource();
    double source = acSourceData_->returnSource();

    bVecReal[li_Pos] -= source;
    bVecReal[li_Neg] += source;

    acSourceData_->setRealFlag(false);

    acSourceData_->updateSource();
    source = acSourceData_->returnSource();

    bVecImag[li_Pos] -= source;
    bVecImag[li_Neg] += source;
  }

  return true;
}

//-----------------------------------------------------------------------------
// Function      : Instance::loadDAEBVector
// Purpose       : Loads the F-vector contributions for a single
//                 ISRC instance.
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 03/05/04
//-----------------------------------------------------------------------------
bool Instance::loadDAEBVector ()
{
  double * bVec = extData.daeBVectorRawPtr;

  // get the source value:
  SourceData *dataPtr = dcSourceData_; // by default assume the DC value.
  if ((HBSpecified_ || getSolverState().tranopFlag || getSolverState().transientFlag || (ACSpecified_ && !DCSOURCETYPEgiven ) ) && tranSourceData_ != 0 )
  {
    dataPtr = tranSourceData_;
  }

  double source = 0.0;
  if (dataPtr != 0)
  {
    source = dataPtr->returnSource();
  }
  bVec[li_Pos] -= source;
  bVec[li_Neg] += source;

  if( loadLeadCurrent )
  {
    double * leadF = extData.nextLeadCurrFCompRawPtr;
    double * junctionV = extData.nextJunctionVCompRawPtr;
    double * solVec = extData.nextSolVectorRawPtr;
    leadF[li_branch_data] = source;
    junctionV[li_branch_data] = solVec[li_Pos] - solVec[li_Neg];
  }

  return true;
}

//-----------------------------------------------------------------------------
// Function      : Model::Model
// Purpose       : copy constructor
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 04/06/00
//-----------------------------------------------------------------------------
Model::Model(
  const Configuration & configuration,
  const ModelBlock &    MB,
  const FactoryBlock &  factory_block)
  : DeviceModel(MB, configuration.getModelParameters(), factory_block)
{

}

//-----------------------------------------------------------------------------
// Function      : Model::~Model
// Purpose       : destructor
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 04/06/00
//-----------------------------------------------------------------------------
Model::~Model ()
{
  std::vector<Instance*>::iterator iter;
  std::vector<Instance*>::iterator first = instanceContainer.begin();
  std::vector<Instance*>::iterator last  = instanceContainer.end();

  for (iter=first; iter!=last; ++iter)
  {
    delete (*iter);
  }
}

// additional Declarations

//----------------------------------------------------------------------------
// Function      : Model::processParams
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Lon Waters
// Creation Date : 07/29/2002
//----------------------------------------------------------------------------
bool Model::processParams()
{
  return true;
}

//----------------------------------------------------------------------------
// Function      : Model::processInstanceParams
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Dave Shirely, PSSI
// Creation Date : 03/23/06
//----------------------------------------------------------------------------
bool Model::processInstanceParams()
{

  std::vector<Instance*>::iterator iter;
  std::vector<Instance*>::iterator first = instanceContainer.begin();
  std::vector<Instance*>::iterator last  = instanceContainer.end();

  for (iter=first; iter!=last; ++iter)
  {
    (*iter)->processParams();
  }

  return true;
}

//-----------------------------------------------------------------------------
// Function      : Model::printOutInstances
// Purpose       : debugging tool.
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 4/03/00
//-----------------------------------------------------------------------------
std::ostream &Model::printOutInstances(std::ostream &os) const
{
  if (DEBUG_DEVICE)
  {
    std::vector<Instance*>::const_iterator iter;
  std::vector<Instance*>::const_iterator first = instanceContainer.begin();
  std::vector<Instance*>::const_iterator last  = instanceContainer.end();

  int i;
  os << std::endl;
  os << "    name     modelName  Parameters" << std::endl;
  for (i=0, iter=first; iter!=last; ++iter, ++i)
  {
    os << "  " << i << ": " << (*iter)->getName() << "      ";
    os << getName();
    os << std::endl;
    if ( (*iter)->tranSourceData_ != 0 )
    {
      (*iter)->tranSourceData_->printOutParams ();
    }

    if ( (*iter)->dcSourceData_ != 0 )
    {
      (*iter)->dcSourceData_->printOutParams ();
    }

    if ( (*iter)->acSourceData_ != 0 )
    {
      (*iter)->acSourceData_->printOutParams ();
    }
  }

  os << std::endl;
  }
  return os;
}

//-----------------------------------------------------------------------------
// Function      : Model::forEachInstance
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : David Baur
// Creation Date : 2/4/2014
//-----------------------------------------------------------------------------
/// Apply a device instance "op" to all instances associated with this
/// model
///
/// @param[in] op Operator to apply to all instances.
///
///
void Model::forEachInstance(DeviceInstanceOp &op) const /* override */
{
  for (std::vector<Instance *>::const_iterator it = instanceContainer.begin(); it != instanceContainer.end(); ++it)
    op(*it);
}

//-----------------------------------------------------------------------------
// ISRC Master functions:
//-----------------------------------------------------------------------------

Master::Master(
  const Configuration & configuration,
  const FactoryBlock &  factory_block,
  const SolverState &   solver_state,
  const DeviceOptions & device_options)
  : DeviceMaster<Traits>(configuration, factory_block, solver_state, device_options),
    HBSpecified_(factory_block.deviceManager_.getHBSpecified()),
    ACSpecified_(factory_block.deviceManager_.getACSpecified())
{}

//-----------------------------------------------------------------------------
// Function      : Master::loadDAEVectors
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL
// Creation Date : 11/26/08
//-----------------------------------------------------------------------------
bool Master::loadDAEVectors (double * solVec, double * fVec, double *qVec,  double * bVec, double * leadF, double * leadQ, double * junctionV)
{
  for (InstanceVector::const_iterator it = getInstanceBegin(); it != getInstanceEnd(); ++it)
  {
    Instance & inst = *(*it);

    SourceData *dataPtr = inst.dcSourceData_; // by default assume the DC value.
    if ((HBSpecified_ || getSolverState().tranopFlag || getSolverState().transientFlag || (ACSpecified_ && !inst.DCSOURCETYPEgiven ) ) && inst.tranSourceData_ != 0 )
    {
      dataPtr = inst.tranSourceData_;
    }

    double source = 0.0;
    if (dataPtr != 0)
    {
      source = dataPtr->returnSource();
    }

    bVec[inst.li_Pos] -= source;
    bVec[inst.li_Neg] += source;

    if( inst.loadLeadCurrent )
    {
      leadF[inst.li_branch_data] = source;
      junctionV[inst.li_branch_data] = solVec[inst.li_Pos] - solVec[inst.li_Neg];
    }


  }
  return true;
}

//-----------------------------------------------------------------------------
// Function      : Master::loadDAEMatrices
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL
// Creation Date : 11/26/08
//-----------------------------------------------------------------------------
bool Master::loadDAEMatrices (Linear::Matrix & dFdx, Linear::Matrix & dQdx)
{
  return true;
}


Device *Traits::factory(const Configuration &configuration, const FactoryBlock &factory_block)
{
  return new DeviceMaster<Traits>(configuration, factory_block, factory_block.solverState_, factory_block.deviceOptions_);
}

void
registerDevice(const DeviceCountMap& deviceMap, const std::set<int>& levelSet)
{
  if (deviceMap.empty() || (deviceMap.find("I")!=deviceMap.end()))
  {
    Config<Traits>::addConfiguration()
      .registerDevice("i", 1);
  }
}

} // namespace Resistor
} // namespace Device
} // namespace Xyce
src/DeviceModelPKG/OpenModels/N_DEV_ISRC.h0000666000175000017500000002013413656722377016432 0ustar  dkcdkc//-------------------------------------------------------------------------
//   Copyright 2002-2020 National Technology & Engineering Solutions of
//   Sandia, LLC (NTESS).  Under the terms of Contract DE-NA0003525 with
//   NTESS, the U.S. Government retains certain rights in this software.
//
//   This file is part of the Xyce(TM) Parallel Electrical Simulator.
//
//   Xyce(TM) 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 3 of the License, or
//   (at your option) any later version.
//
//   Xyce(TM) 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 Xyce(TM).
//   If not, see <http://www.gnu.org/licenses/>.
//-------------------------------------------------------------------------

//-----------------------------------------------------------------------------
//
// Purpose        : Independent current source
//
// Special Notes  :
//
// Creator        : Eric R. Keiter, SNL, Parallel Computational Sciences
//
// Creation Date  : 02/28/00
//
//
//
//
//-----------------------------------------------------------------------------

#ifndef Xyce_N_DEV_ISRC_h
#define Xyce_N_DEV_ISRC_h

// ----------   Xyce Includes   ----------
#include <N_DEV_Configuration.h>
#include <N_DEV_DeviceBlock.h>
#include <N_DEV_DeviceInstance.h>
#include <N_DEV_DeviceMaster.h>
#include <N_DEV_DeviceModel.h>
#include <N_DEV_Param.h>
#include <N_DEV_Source.h>

namespace Xyce {
namespace Device {
namespace ISRC {

class Model;
class Instance;

struct Traits : public DeviceTraits<Model, Instance>
{
  static const char *name() {return "Independent Current Source";}
  static const char *deviceTypeName() {return "I level 1";}
  static int numNodes() {return 2;}
  static const char *primaryParameter() {return "DCV0";}
  static const char *instanceDefaultParameter() {return "DCV0";}
  static bool isLinearDevice() {return true;}

  static Device *factory(const Configuration &configuration, const FactoryBlock &factory_block);
  static void loadModelParameters(ParametricData<Model> &model_parameters);
  static void loadInstanceParameters(ParametricData<Instance> &instance_parameters);
};

//-----------------------------------------------------------------------------
// Class         : Instance
// Purpose       :
// Special Notes :
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 04/06/00
//-----------------------------------------------------------------------------
class Instance : public SourceInstance
{
  friend class ParametricData<Instance>;
  friend class Model;
  friend struct Traits;
  friend class Master;

public:
  Instance(
     const Configuration &     configuration,
     const InstanceBlock &     instance_block,
     Model &                   model,
     const FactoryBlock &      factory_block);

  ~Instance();

private:
  Instance(const Instance &);
  Instance &operator=(const Instance &);

public:
 
  bool isLinearDevice() const { return true; }

  void registerLIDs( const std::vector<int> & intLIDVecRef,
                     const std::vector<int> & extLIDVecRef);
  void registerStateLIDs( const std::vector<int> & staLIDVecRef);

  void registerStoreLIDs(const std::vector<int> & stoLIDVecRef );
  void registerBranchDataLIDs(const std::vector<int> & branchLIDVecRef);
  virtual void loadNodeSymbols(Util::SymbolTable &symbol_table) const; // override

  const std::vector< std::vector<int> > & jacobianStamp() const;

  bool processParams ();

  bool updateIntermediateVars () { return true; }
  bool updatePrimaryState () { return true; }

  // load functions, residual:
  bool loadDAEQVector () { return true; }
  bool loadDAEFVector () { return true; }
  bool loadDAEBVector ();

  // load functions, Jacobian:
  bool loadDAEdQdx () { return true; }
  bool loadDAEdFdx () { return true; }

  bool loadBVectorsforAC (double * bVecReal, double * bVecImag);

protected:
private:

public:
  // iterator reference to the ISRC model that owns this instance.
  // Getters and setters
  Model &getModel() 
  {
    return model_;
  }

private:
  static std::vector< std::vector<int> > jacStamp;
  static std::vector< std::vector<int> > jacStampPDE;

  Model &       model_;         //< Owning model

  // index variables:
  int li_Pos;
  int li_Neg;

  // Store variables
  int li_branch_data;   ///< Index for lead current and junction voltage (for power calculations)

  bool          HBSpecified_;
  bool          ACSpecified_;

  // Parameters
  double DCV0;
  double par0;
  double par1;
  double par2;
  double par3;
  double par4;
  double par5;
  double par6;
  double REPEATTIME;
  double T;
  double V;
  std::string DATA;
  int RB;
  int NUM;
  bool REPEAT;
  int TRANSIENTSOURCETYPE;
  bool TRANSIENTSOURCETYPEgiven;
  int ACSOURCETYPE;
  bool ACSOURCETYPEgiven;
  int DCSOURCETYPE;
  bool DCSOURCETYPEgiven;
  bool gotParams;

  double ACMAG;
  double ACPHASE;

public:
  inline int liPos() const {return li_Pos;}
  inline int liNeg() const {return li_Neg;}

  inline const ExternData *extDataPtr() const {return &extData;} 
};

//-----------------------------------------------------------------------------
// Class         : Model
// Purpose       :
// Special Notes :
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 04/06/00
//-----------------------------------------------------------------------------
class Model : public DeviceModel
{
  typedef std::vector<Instance *> InstanceVector;

  friend class Instance;
  friend struct Traits;
  friend class Master;

public:
  Model(
     const Configuration &       configuration,
     const ModelBlock &        MB,
     const FactoryBlock &      factory_block);
  ~Model ();

private:
  Model();
  Model(const Model &);
  Model &operator=(const Model &);

public:
  virtual void forEachInstance(DeviceInstanceOp &op) const /* override */;

  virtual std::ostream &printOutInstances(std::ostream &os) const;
  virtual bool processParams();
  virtual bool processInstanceParams();

public:
  void addInstance(Instance *instance) 
  {
    instanceContainer.push_back(instance);
  }

  void setupBaseInstanceContainer()
  {
    std::vector<Instance*>::iterator iter = instanceContainer.begin();
    std::vector<Instance*>::iterator end   = instanceContainer.end();
    for ( ; iter!=end; ++iter)
    {
      Xyce::Device::DeviceModel::baseInstanceContainer.push_back( static_cast<Xyce::Device::DeviceInstance *>(*iter) );
    }
  }

private:
  std::vector<Instance*> instanceContainer;

private:
};

//-----------------------------------------------------------------------------
// Class         : Master
// Purpose       :
// Special Notes :
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 11/26/08
//-----------------------------------------------------------------------------
class Master : public DeviceMaster<Traits>
{
  friend class Instance;
  friend class Model;

public:
  Master(
    const Configuration &       configuration,
    const FactoryBlock &        factory_block,
    const SolverState &         solver_state,
    const DeviceOptions &       device_options);

  virtual bool updateState (double * solVec, double * staVec, double * stoVec) { return true; }
  virtual bool updateSecondaryState (double * staDerivVec, double * stoVec) { return true; }

  // new DAE stuff:
  // new DAE load functions, residual:
  virtual bool loadDAEVectors (double * solVec, double * fVec, double * qVec, double * bVec,
                               double * leadF, double * leadQ, double * junctionV);

  // new DAE load functions, Jacobian:
  virtual bool loadDAEMatrices (Linear::Matrix & dFdx, Linear::Matrix & dQdx);

private:

  bool          HBSpecified_;
  bool          ACSpecified_;
};

void registerDevice(const DeviceCountMap& deviceMap, const std::set<int>& levelSet);

} // namespace ISRC
} // namespace Device
} // namespace Xyce

#endif

src/DeviceModelPKG/OpenModels/N_DEV_Vsrc.C0000644000175000017500000011041213660205157016520 0ustar  dkcdkc//-------------------------------------------------------------------------
//   Copyright 2002-2020 National Technology & Engineering Solutions of
//   Sandia, LLC (NTESS).  Under the terms of Contract DE-NA0003525 with
//   NTESS, the U.S. Government retains certain rights in this software.
//
//   This file is part of the Xyce(TM) Parallel Electrical Simulator.
//
//   Xyce(TM) 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 3 of the License, or
//   (at your option) any later version.
//
//   Xyce(TM) 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 Xyce(TM).
//   If not, see <http://www.gnu.org/licenses/>.
//-------------------------------------------------------------------------

//-------------------------------------------------------------------------
//
// Purpose        :
//
// Special Notes  :
//
// Creator        : Eric R. Keiter, SNL, Parallel Computational Sciences
//
// Creation Date  : 02/28/00
//
//
//
//
//-------------------------------------------------------------------------
#include <Xyce_config.h>

// ---------- Standard Includes ----------

// ----------   Xyce Includes   ----------
#include <N_DEV_DeviceMgr.h>
#include <N_DEV_DeviceOptions.h>
#include <N_DEV_ExternData.h>
#include <N_DEV_MatrixLoadData.h>
#include <N_DEV_SolverState.h>
#include <N_DEV_SourceData.h>
#include <N_DEV_Vsrc.h>
#include <N_DEV_Message.h>
#include <N_ERH_ErrorMgr.h>

#include <N_LAS_Vector.h>
#include <N_LAS_Matrix.h>
#include <N_UTL_BreakPoint.h>
#include <N_UTL_FeatureTest.h>

namespace Xyce {
namespace Device {

namespace Vsrc {

void Traits::loadInstanceParameters(ParametricData<Vsrc::Instance> &p)
{
    p.addPar ("DCV0", 0.0, &Vsrc::Instance::DCV0)
      .setOriginalValueStored(true)
      .setUnit(U_VOLT)
      .setDescription("DC Voltage")
      .setAnalyticSensitivityAvailable(true)
      .setSensitivityFunctor(&dcv0Sens);

    // Pulse parameters
    p.addPar ("V0", 0.0, &Vsrc::Instance::par0)
     .setUnit(U_VOLT)
     .setCategory(CAT_NONE)
     .setDescription("Offset Voltage");

    p.addPar ("V1", 0.0, &Vsrc::Instance::par0)
     .setUnit(U_VOLT)
     .setCategory(CAT_NONE)
     .setDescription("Initial Voltage");

    p.addPar ("V2", 0.0, &Vsrc::Instance::par1)
     .setUnit(U_VOLT)
     .setCategory(CAT_NONE)
     .setDescription("Pulsed Voltage");

    p.addPar ("TD", 0.0, &Vsrc::Instance::par2)
     .setUnit(U_SECOND)
     .setCategory(CAT_NONE)
     .setDescription("Delay");

    p.addPar ("TR", 0.0, &Vsrc::Instance::par3)
     .setUnit(U_SECOND)
     .setCategory(CAT_NONE)
     .setDescription("Rise Time");

    p.addPar ("TF", 0.0, &Vsrc::Instance::par4)
     .setUnit(U_SECOND)
     .setCategory(CAT_NONE)
     .setDescription("Fall Time");

    p.addPar ("PW", 0.0, &Vsrc::Instance::par5)
     .setUnit(U_SECOND)
     .setCategory(CAT_NONE)
     .setDescription("Pulse Width");

    p.addPar ("PER", 0.0, &Vsrc::Instance::par6)
     .setUnit(U_SECOND)
     .setCategory(CAT_NONE)
     .setDescription("Period");

    // Sin parameters
    p.addPar ("VA", 0.0, &Vsrc::Instance::par1)
     .setUnit(U_VOLT)
     .setCategory(CAT_NONE)
     .setDescription("Amplitude");

    p.addPar ("FREQ", 0.0, &Vsrc::Instance::par3)
     .setUnit(U_SECM1)
     .setCategory(CAT_NONE)
     .setDescription("Frequency");

    p.addPar ("THETA", 0.0, &Vsrc::Instance::par4)
     .setUnit(U_NONE)
     .setCategory(CAT_NONE)
     .setDescription("Theta");

    p.addPar ("PHASE", 0.0, &Vsrc::Instance::par5)
     .setUnit(U_NONE)
     .setCategory(CAT_NONE)
     .setDescription("Phase");

    // Exp parameters
    p.addPar ("TD1", 0.0, &Vsrc::Instance::par2)
     .setUnit(U_SECOND)
     .setCategory(CAT_NONE)
     .setDescription("Rise Delay Time");

    p.addPar ("TAU1", 0.0, &Vsrc::Instance::par3)
     .setUnit(U_SECOND)
     .setCategory(CAT_NONE)
     .setDescription("Rise Time Constant");

    p.addPar ("TD2", 0.0, &Vsrc::Instance::par4)
      .setUnit(U_SECOND)
     .setCategory(CAT_NONE)
     .setDescription("Fall Delay Time");

    p.addPar ("TAU2", 0.0, &Vsrc::Instance::par5)
     .setUnit(U_SECOND)
     .setCategory(CAT_NONE)
     .setDescription("Fall Time Constant");

    // AC parameters
    p.addPar ("ACMAG", 0.0, &Vsrc::Instance::ACMAG)
     .setUnit(U_VOLT)
     .setCategory(CAT_NONE)
     .setDescription("Amplitude")
     .setAnalyticACSensitivityAvailable(true)
     .setACSensitivityFunctor(&acMagSens);

    p.addPar ("ACPHASE", 0.0, &Vsrc::Instance::ACPHASE)
     .setUnit(U_NONE)
     .setCategory(CAT_NONE)
     .setDescription("Phase")
     .setAnalyticACSensitivityAvailable(true)
     .setACSensitivityFunctor(&acPhaseSens);

    // SFFM parameters
    p.addPar ("FC", 0.0, &Vsrc::Instance::par2)
     .setUnit(U_SECM1)
     .setCategory(CAT_NONE)
     .setDescription("Carrier Frequency");

    p.addPar ("FS", 0.0, &Vsrc::Instance::par4)
     .setUnit(U_SECM1)
     .setCategory(CAT_NONE)
     .setDescription("Signal Frequency");

    p.addPar ("MDI", 0.0, &Vsrc::Instance::par3)
     .setUnit(U_NONE)
     .setCategory(CAT_NONE)
     .setDescription("Modulation Index");

    // PWL params
    p.addPar ("R", 0.0, &Vsrc::Instance::REPEATTIME)
     .setUnit(U_SECOND)
     .setCategory(CAT_NONE)
     .setDescription("Repeat Time");

    p.addPar ("T", 0.0, &Vsrc::Instance::T)
     .setUnit(U_SECOND)
     .setCategory(CAT_NONE)
     .setDescription("Time");  // time-voltage pairs

    p.addPar ("V", 0.0, &Vsrc::Instance::V)
     .setUnit(U_VOLT)
     .setCategory(CAT_NONE)
     .setDescription("Voltage"); // time-voltage pairs

    // PAT params
    p.addPar ("VHI", 0.0, &Vsrc::Instance::par0)
     .setUnit(U_VOLT)
     .setCategory(CAT_NONE)
     .setDescription("High Voltage Value");

    p.addPar ("VLO", 0.0, &Vsrc::Instance::par1)
     .setUnit(U_VOLT)
     .setCategory(CAT_NONE)
     .setDescription("Low Voltage Value");

    p.addPar ("TSAMPLE", 0.0, &Vsrc::Instance::par5)
     .setUnit(U_SECOND)
     .setCategory(CAT_NONE)
     .setDescription("Pulse Width");

    p.addPar ("DATA", "", &Vsrc::Instance::DATA)
     .setUnit(U_NONE)
     .setCategory(CAT_NONE)
     .setDescription("Data Pattern");

    p.addPar ("RB", 1, &Vsrc::Instance::RB)
     .setUnit(U_NONE)
     .setCategory(CAT_NONE)
     .setDescription("Starting Bit When Repeating");

    // Set up exceptions (ie variables that are not doubles):
    p.addPar ("TRANSIENTSOURCETYPE", (int) _DC_DATA, &Vsrc::Instance::TRANSIENTSOURCETYPE)
     .setGivenMember(&Vsrc::Instance::TRANSIENTSOURCETYPEgiven)
     .setUnit(U_NONE)
     .setCategory(CAT_NONE)
     .setDescription("" );

    p.addPar ("ACSOURCETYPE", (int) _AC_DATA, &Vsrc::Instance::ACSOURCETYPE)
     .setGivenMember(&Vsrc::Instance::ACSOURCETYPEgiven)
     .setUnit(U_NONE)
     .setCategory(CAT_NONE)
     .setDescription("" );

    p.addPar ("DCSOURCETYPE", (int) _DC_DATA, &Vsrc::Instance::DCSOURCETYPE)
     .setGivenMember(&Vsrc::Instance::DCSOURCETYPEgiven)
     .setUnit(U_NONE)
     .setCategory(CAT_NONE)
     .setDescription("" );

    p.addPar ("NUM", 0, &Vsrc::Instance::NUM)
     .setUnit(U_NONE)
     .setCategory(CAT_NONE)
     .setDescription("" );

    // port parameters
    p.addPar ("PORT", 0, &Vsrc::Instance::port)
     .setGivenMember(&Vsrc::Instance::PORTgiven)
     .setUnit(U_NONE)
     .setCategory(CAT_NONE)
     .setDescription("port number");

    p.addPar ("Z0", 50.0, &Vsrc::Instance::Z0)
         
     .setGivenMember(&Vsrc::Instance::Z0given)
     .setUnit(U_OHM)
     .setCategory(CAT_NONE)
     .setDescription("impedance");
}

void Traits::loadModelParameters(ParametricData<Vsrc::Model> &p)
{
}


std::vector< std::vector<int> > Instance::jacStamp;
std::vector< std::vector<int> > Instance::jacStampPDE;

// Class Instance
//-----------------------------------------------------------------------------
// Function      : Instance::Instance
// Purpose       : "instance block" constructor
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 04/06/00
//-----------------------------------------------------------------------------
Instance::Instance(
  const Configuration & configuration,
  const InstanceBlock &         IB,
  Model &                       Viter,
  const FactoryBlock &          factory_block)
  : SourceInstance(IB, configuration.getInstanceParameters(), factory_block),
    model_(Viter),
    srcCurrent(0.0),
    srcDrop(0.0),
    srcBC(0.0),
    HBSpecified_(factory_block.deviceManager_.getHBSpecified()),
    ACSpecified_(factory_block.deviceManager_.getACSpecified()),
    DCV0(0.0),
    par0(0.0),
    par1(0.0),
    par2(0.0),
    par3(0.0),
    par4(0.0),
    par5(0.0),
    par6(0.0),
    REPEATTIME(),
    T(0.0),
    V(0.0),
    ACMAG(1.0),
    ACPHASE(0.0),
    DATA(""),
    RB(1),
    NUM(0),
    REPEAT(false),

    TRANSIENTSOURCETYPE(_DC_DATA),
    TRANSIENTSOURCETYPEgiven(false),
    ACSOURCETYPE(_AC_DATA),
    ACSOURCETYPEgiven(false),
    DCSOURCETYPE(_AC_DATA),
    DCSOURCETYPEgiven(false),
    gotParams(false),
    v_pos(0.0),
    v_neg(0.0),
    i_bra(0.0),

    li_Pos(-1),
    li_Neg(-1),
    li_Bra(-1),
    li_branch_data(0),

    ABraEquPosNodeOffset(-1),
    ABraEquNegNodeOffset(-1),
    APosEquBraVarOffset(-1),
    ANegEquBraVarOffset(-1),
    APosEquPosNodeOffset(-1),
    ANegEquNegNodeOffset(-1),
    ABraEquBraVarOffset(-1),

#ifndef Xyce_NONPOINTER_MATRIX_LOAD
    fBraEquPosNodePtr(0),
    fBraEquNegNodePtr(0),
    fPosEquBraVarPtr(0),
    fNegEquBraVarPtr(0),
    fPosEquPosNodePtr(0),
    fNegEquNegNodePtr(0),
    fBraEquBraVarPtr(0),
#endif

    port(0),
    Z0(50.0),
    PORTgiven (false),
    Z0given (false)
{
  numIntVars   = 1;
  numExtVars   = 2;
  numStateVars = 0;
  setNumBranchDataVars(0);             // by default don't allocate space in branch vectors
  numBranchDataVarsIfAllocated = 1;    // this is the space to allocate if lead current or power is needed.

  if( jacStamp.empty() )
  {
    jacStamp.resize(3);
    jacStamp[0].resize(1);
    jacStamp[0][0] = 2;
    jacStamp[1].resize(1);
    jacStamp[1][0] = 2;
    jacStamp[2].resize(2);
    jacStamp[2][0] = 0;
    jacStamp[2][1] = 1;

    // PDE supporting stamp.  This includes diagonal elements, needed by the
    // 2-level Newton.
    jacStampPDE.resize(3);
    jacStampPDE[0].resize(2);
    jacStampPDE[0][0] = 0;
    jacStampPDE[0][1] = 2;
    jacStampPDE[1].resize(2);
    jacStampPDE[1][0] = 1;
    jacStampPDE[1][1] = 2;
    jacStampPDE[2].resize(3);
    jacStampPDE[2][0] = 0;
    jacStampPDE[2][1] = 1;
    jacStampPDE[2][2] = 2;
  }

  // Set params to constant default values:
  setDefaultParams ();

  // Set params according to instance line and constant defaults from metadata:
  Src_mod mods = setParams (IB.params);

  const SolverState &solver_state = factory_block.solverState_;
  const DeviceOptions &device_options = factory_block.deviceOptions_;

  // Set any non-constant parameter defaults:
  if (ACSpecified_ && ACSOURCETYPEgiven)
  {
    acSourceData_ = new ACData(*this, IB.params, solver_state, device_options);
  }

//  if (DCSOURCETYPEgiven) // this will always be given, if the source spec was valid.
    dcSourceData_ = new ConstData(*this, IB.params, solver_state, device_options);

  if (HBSpecified_ || TRANSIENTSOURCETYPEgiven)
  {
    switch (TRANSIENTSOURCETYPE|mods)
    {
      case _SIN_DATA:
        tranSourceData_ = new SinData(*this, IB.params, solver_state, device_options);
        break;

      case _EXP_DATA:
        tranSourceData_ = new ExpData(*this, IB.params, solver_state, device_options);
        break;

      case _PULSE_DATA:
        tranSourceData_ = new PulseData(*this, IB.params, solver_state, device_options);
        break;

      case _PWL_DATA:
        tranSourceData_ = new PWLinData(*this, IB.params, solver_state, device_options);
        break;

      case _PWL_DATA | _DYNAMIC_SRC: {
        PWLinDynData *src = new PWLinDynData(*this, IB.params, solver_state, device_options);
        tranSourceData_ = src;
        if (src->CallBridge(PWLinDynData::Init,this) < 0) { // initialize bridge
            UserFatal(*this) << "Failed to connect URI " << getName();
        }
      } break;

      case _PAT_DATA:
        tranSourceData_ = new PatData(*this, IB.params, solver_state, device_options);
        break;

      case _SFFM_DATA:
        tranSourceData_ = new SFFMData(*this, IB.params, solver_state, device_options);
        break;

      case _DC_DATA:
        tranSourceData_ = 0; // this forces  us to use the dcSourceData_ object instead
        break;

      default:
        UserFatal(*this) << "Cannot identify source data type for " << getName();
        break;
    }
  }

  processParams();

  // Calculate any parameters specified as expressions:
  updateDependentParameters();
  processParams();

  // calculate dependent (ie computed) params and check for errors:

  if( PORTgiven )
  {                  

    jacStamp[2].resize(3);
    jacStamp[2][0] = 0;
    jacStamp[2][1] = 1;
    jacStamp[2][2] = 2;
  }
          
}

extern "C" {

int InstanceGetVsrcV(DeviceInstance *dev_inst,double *ret) {
    Instance *inst = (Instance *)dev_inst;
    return 0;
}

}

//-----------------------------------------------------------------------------
// Function      : Instance::processParams
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 07/26/03
//-----------------------------------------------------------------------------
bool Instance::processParams()
{
  if (gotParams)
  {
    if (dcSourceData_ != 0)
    {
      dcSourceData_->setParams (&DCV0);
    }
    if (acSourceData_ != 0)
    {
      acSourceData_->setParams (&ACMAG);
    }
    if (tranSourceData_ != 0)
    {
      tranSourceData_->setParams(&par0);
    }
  }
  else
  {
    if (dcSourceData_ != 0)
    {
      dcSourceData_->getParams (&DCV0);
    }
    if (acSourceData_ != 0)
    {
      acSourceData_->getParams (&ACMAG);
    }
    if (tranSourceData_ != 0)
    {
      tranSourceData_->getParams(&par0);
    }
    gotParams = true;
  }

  return true;
}

//-----------------------------------------------------------------------------
// Function      : Instance::~Instance
// Purpose       : destructor
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 04/06/00
//-----------------------------------------------------------------------------
Instance::~Instance ()
{
  delete tranSourceData_;
  delete acSourceData_;
  delete dcSourceData_;
}

// Additional Declarations

//-----------------------------------------------------------------------------
// Function      : Instance::registerLIDs
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Robert Hoekstra, SNL, Parallel Computational Sciences
// Creation Date : 6/20/02
//-----------------------------------------------------------------------------
void Instance::registerLIDs ( const std::vector<int> & intLIDVecRef,
	                                const std::vector<int> & extLIDVecRef)
{
  std::string msg;

  if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) )
  {
    Xyce::dout() << std::endl << section_divider << std::endl;
    Xyce::dout() << "  VsrcInstance::registerLIDs" << std::endl;
    Xyce::dout() << "  name = " << getName() << std::endl;
  }

  // Check if the size of the ID lists corresponds to the
  // proper number of internal and external variables.
  int numInt = intLIDVecRef.size();
  int numExt = extLIDVecRef.size();

  if (numInt != numIntVars)
  {
    DevelFatal(*this).in("Instance::registerLIDs") << "numInt != numIntVars";
  }

  if (numExt != numExtVars)
  {
    DevelFatal(*this).in("Instance::registerLIDs") << "numExt != numExtVars";
  }

  // copy over the global ID lists.
  intLIDVec = intLIDVecRef;
  extLIDVec = extLIDVecRef;

  // Now use these lists to obtain the indices into the
  // linear algebra entities.  This assumes an order.
  // For the matrix  indices, first do the rows.

  li_Pos = extLIDVec[0];
  li_Neg = extLIDVec[1];
  li_Bra = intLIDVec[0];

  if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) )
  {
    Xyce::dout() << "  li_Pos = " << li_Pos << std::endl;
    Xyce::dout() << "  li_Neg = " << li_Neg << std::endl;
    Xyce::dout() << "  li_Bra = " << li_Bra << std::endl;
    Xyce::dout() << section_divider << std::endl;
  }
}

//-----------------------------------------------------------------------------
// Function      : Xyce::Device::Resistor::Instance::registerBranchDataLIDs
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Richard Schiek, Electrical Systems Modeling
// Creation Date : 12/18/2012
//-----------------------------------------------------------------------------
/// Register the local store IDs
///
/// In addition to state vector, Xyce maintains a separate datastructure
/// called a "branch data" vector.  As with other such vectors, the device
/// declares at construction time how many branch vector entries it needs,
/// and later Topology assigns locations for devices, returning LIDs.
///
/// These LIDs are stored in this method for later use.
///
/// The Voltage Source device uses exactly one "branch data vector" element, where
/// it keeps the "lead current" that may be used on .PRINT lines as
/// "I(V1)" for the current through resistor V1. and a junction voltage.
///
///
/// @param stoLIDVecRef Store variable local IDs
///
/// @author Richard Schiek, Electrical Systems Modeling
/// @date   12/18/2012
void Instance::registerBranchDataLIDs(const std::vector<int> & branchLIDVecRef)
{
  AssertLIDs(branchLIDVecRef.size() == getNumBranchDataVars());

  if (loadLeadCurrent)
  {
    li_branch_data= branchLIDVecRef[0];
  }
}

//-----------------------------------------------------------------------------
// Function      : Instance::loadNodeSymbols
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric R. Keiter, SNL, Parallel Computational Sciences
// Creation Date : 05/13/05
//-----------------------------------------------------------------------------
void Instance::loadNodeSymbols(Util::SymbolTable &symbol_table) const
{
  addInternalNode(symbol_table, li_Bra, getName(), "branch");
  if (loadLeadCurrent)
  {
    addBranchDataNode( symbol_table, li_branch_data, getName(), "BRANCH_D");
  }
}

//-----------------------------------------------------------------------------
// Function      : Instance::registerStateLIDs
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Robert Hoekstra, SNL, Parallel Computational Sciences
// Creation Date : 6/20/02
//-----------------------------------------------------------------------------
void Instance::registerStateLIDs( const std::vector<int> & staLIDVecRef )
{
  AssertLIDs(staLIDVecRef.size() == numStateVars);
}

//-----------------------------------------------------------------------------
// Function      : Instance::jacobianStamp
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Robert Hoekstra, SNL, Parallel Computational Sciences
// Creation Date : 8/21/02
//-----------------------------------------------------------------------------
const std::vector< std::vector<int> > & Instance::jacobianStamp() const
{
  if (getSolverState().isPDESystem_)
    return jacStampPDE;

  return jacStamp;
}

//-----------------------------------------------------------------------------
// Function      : Instance::registerJacLIDs
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Robert Hoekstra, SNL, Parallel Computational Sciences
// Creation Date : 8/27/02
//-----------------------------------------------------------------------------
void Instance::registerJacLIDs( const std::vector< std::vector<int> > & jacLIDVec )
{
  DeviceInstance::registerJacLIDs( jacLIDVec );
  if (getSolverState().isPDESystem_)
  {
    APosEquBraVarOffset  = jacLIDVec[0][1];
    ANegEquBraVarOffset  = jacLIDVec[1][1];
    ABraEquPosNodeOffset = jacLIDVec[2][0];
    ABraEquNegNodeOffset = jacLIDVec[2][1];
  }
  else
  {
    APosEquBraVarOffset  = jacLIDVec[0][0];
    ANegEquBraVarOffset  = jacLIDVec[1][0];
    ABraEquPosNodeOffset = jacLIDVec[2][0];
    ABraEquNegNodeOffset = jacLIDVec[2][1];

    if( PORTgiven )
      ABraEquBraVarOffset = jacLIDVec[2][2];
  }
}

//-----------------------------------------------------------------------------
// Function      : Instance::setupPointers
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL
// Creation Date : 11/30/08
//-----------------------------------------------------------------------------
void Instance::setupPointers ()
{
#ifndef Xyce_NONPOINTER_MATRIX_LOAD
  Linear::Matrix & dFdx = *(extData.dFdxMatrixPtr);

  fPosEquBraVarPtr = &(dFdx[li_Pos][APosEquBraVarOffset]);
  fNegEquBraVarPtr = &(dFdx[li_Neg][ANegEquBraVarOffset]);
  fBraEquPosNodePtr = &(dFdx[li_Bra][ABraEquPosNodeOffset]);
  fBraEquNegNodePtr = &(dFdx[li_Bra][ABraEquNegNodeOffset]);

  if( PORTgiven )
    fBraEquBraVarPtr = &(dFdx[li_Bra][ABraEquBraVarOffset]);

#endif
}

//-----------------------------------------------------------------------------
// Function      : Instance::loadDAEFVector
// Purpose       : Loads the F-vector contributions for a single vsrc instance.
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL
// Creation Date :
//-----------------------------------------------------------------------------
bool Instance::loadDAEFVector ()
{
  double * fVec = extData.daeFVectorRawPtr;
  double * solVec = extData.nextSolVectorRawPtr;

  srcCurrent        = solVec[li_Bra];
  srcDrop           = (solVec[li_Pos]-solVec[li_Neg]);

  if( PORTgiven && !getSolverState().spAnalysisFlag_ ) 
    srcDrop  -= srcCurrent * Z0;

  fVec[li_Pos] += srcCurrent;
  fVec[li_Neg] += -srcCurrent;
  fVec[li_Bra] += srcDrop;

  if( loadLeadCurrent )
  {
    double * leadF = extData.nextLeadCurrFCompRawPtr;
    double * junctionV = extData.nextJunctionVCompRawPtr;
    leadF[li_branch_data] = srcCurrent;
    junctionV[li_branch_data] = srcDrop;
  }

  return true;
}

//-----------------------------------------------------------------------------
// Function      : Instance::loadDAEBVector
//
// Purpose       : Loads the B-vector contributions for a single
//                 vsrc instance.
//
// Special Notes :
//
// Scope         : public
// Creator       : Eric Keiter, SNL
// Creation Date :
//-----------------------------------------------------------------------------
bool Instance::loadDAEBVector ()
{
  // Get the value for the source.
  SourceData *dataPtr  = dcSourceData_; // by default assume the DC value.
  if ((HBSpecified_ || getSolverState().tranopFlag || getSolverState().transientFlag || (ACSpecified_ && !DCSOURCETYPEgiven ) ) && tranSourceData_ != 0 )
  {
    dataPtr = tranSourceData_;
  }

  if (dataPtr != 0)
  {
    srcBC = dataPtr->returnSource();
  }
  else
  {
    srcBC = 0.0;
  }

  double * bVec = extData.daeBVectorRawPtr;
  bVec[li_Bra] += srcBC;

  return true;
}

//-----------------------------------------------------------------------------
// Function      : Instance::loadBVectorsforAC
//
// Purpose       : Loads the B-vector contributions for a single
//                 vsrc instance.
//
// Special Notes :
//
// Scope         : public
// Creator       : Ting Mei, SNL
// Creation Date : 5/11
//-----------------------------------------------------------------------------
bool Instance::loadBVectorsforAC(double * bVecReal, double * bVecImag )
{
  if (acSourceData_ != 0)
  {
    bool flag = true;
    acSourceData_->setRealFlag(flag);

    acSourceData_->updateSource ();
    srcBC = acSourceData_->returnSource();

    bVecReal[li_Bra] += srcBC;

    flag = false;
    acSourceData_->setRealFlag(flag);

    acSourceData_->updateSource ();
    srcBC = acSourceData_->returnSource();

    bVecImag[li_Bra] += srcBC;
  }

  return true;
}

//-----------------------------------------------------------------------------
// Function      : Instance::loadDAEdFdx ()
//
// Purpose       : Loads the F-vector contributions for a single
//                 vsrc instance.
//
// Special Notes :
//
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 03/05/04
//-----------------------------------------------------------------------------
bool Instance::loadDAEdFdx ()
{
  Linear::Matrix & dFdx = *(extData.dFdxMatrixPtr);

  dFdx[li_Pos][APosEquBraVarOffset] += 1.0;
  dFdx[li_Neg][ANegEquBraVarOffset] -= 1.0;
  dFdx[li_Bra][ABraEquPosNodeOffset] += 1.0;
  dFdx[li_Bra][ABraEquNegNodeOffset] -= 1.0;


  if( PORTgiven && !getSolverState().spAnalysisFlag_ ) 
    dFdx[li_Bra][ABraEquBraVarOffset] -= Z0;

  return true;
}

// end of new-DAE functions

//-----------------------------------------------------------------------------
// Function      : Instance::getMaxTimeStepSize
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 07/23/03
//-----------------------------------------------------------------------------
double Instance::getMaxTimeStepSize  ()
{
  double maxStep = 1.0e+100;
  if (tranSourceData_ != 0)
  {
    maxStep = tranSourceData_->getMaxTimeStepSize ();
  }
  return maxStep;
}

//-----------------------------------------------------------------------------
// Function      : Instance::varTypes
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Rob Hoekstra, SNL, Parallel Computational Sciences
// Creation Date : 02/17/04
//-----------------------------------------------------------------------------
void Instance::varTypes( std::vector<char> & varTypeVec )
{
  varTypeVec.resize(1);
  varTypeVec[0] = 'I';
}

// Class Model

//-----------------------------------------------------------------------------
// Function      : Model::Model
// Purpose       : copy constructor
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 04/06/00
//-----------------------------------------------------------------------------
Model::Model(
  const Configuration & configuration,
  const ModelBlock &    MB,
  const FactoryBlock &  factory_block)
  : DeviceModel(MB, configuration.getModelParameters(), factory_block),
    DC_TRAN (0)
{
}

//-----------------------------------------------------------------------------
// Function      : Model::~Model
// Purpose       : destructor
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 04/06/00
//-----------------------------------------------------------------------------
Model::~Model ()
{
  std::vector<Instance*>::iterator iter;
  std::vector<Instance*>::iterator first = instanceContainer.begin();
  std::vector<Instance*>::iterator last  = instanceContainer.end();

  for (iter=first; iter!=last; ++iter)
  {
    delete (*iter);
  }
}

// Additional Declarations

//-----------------------------------------------------------------------------
// Function      : Model::printOutInstances
// Purpose       : debugging tool.
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 4/03/00
//-----------------------------------------------------------------------------
std::ostream &Model::printOutInstances(std::ostream &os) const
{
  std::vector<Instance*>::const_iterator iter;
  std::vector<Instance*>::const_iterator first = instanceContainer.begin();
  std::vector<Instance*>::const_iterator last  = instanceContainer.end();

  int i;
  os << std::endl;
  os << "    name     model name  Parameters" << std::endl;
  for (i=0, iter=first; iter!=last; ++iter, ++i)
  {
    os << "  " << i << ": " << (*iter)->getName() << "      ";
    os << getName();
    os << std::endl;
  }

  os << std::endl;

  return os;
}

//-----------------------------------------------------------------------------
// Function      : Model::forEachInstance
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : David Baur
// Creation Date : 2/4/2014
//-----------------------------------------------------------------------------
/// Apply a device instance "op" to all instances associated with this
/// model
///
/// @param[in] op Operator to apply to all instances.
///
///
void Model::forEachInstance(DeviceInstanceOp &op) const /* override */
{
  for (std::vector<Instance *>::const_iterator it = instanceContainer.begin(); it != instanceContainer.end(); ++it)
    op(*it);
}

//-----------------------------------------------------------------------------
// Vsrc Master functions:
//-----------------------------------------------------------------------------

Master::Master(
  const Configuration & configuration,
  const FactoryBlock &  factory_block,
  const SolverState &   solver_state,
  const DeviceOptions & device_options)
  : DeviceMaster<Traits>(configuration, factory_block, solver_state, device_options),
    HBSpecified_(factory_block.deviceManager_.getHBSpecified()),
    ACSpecified_(factory_block.deviceManager_.getACSpecified()),
    separateInstances_(false)
  {}

//-----------------------------------------------------------------------------
// Function      : Master::loadDAEVectors
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL
// Creation Date : 11/26/08
//-----------------------------------------------------------------------------
bool Master::loadDAEVectors (double * solVec, double * fVec, double *qVec,  double * bVec, 
                             double * leadF, double * leadQ, double * junctionV, int loadType)
{
  InstanceVector::const_iterator it, end;

  if (loadType == LINEAR_FREQ)
    loadType = LINEAR;

  if (!separateInstances_ && ( loadType == LINEAR || loadType == NONLINEAR ))
  {
    separateInstanceTypes(linearInstances_, nonlinearInstances_);
    separateInstances_ = true;
  }

  if (loadType == ALL)
  {
    it = getInstanceBegin();
    end = getInstanceEnd();
  }
  else if (loadType == LINEAR)
  {
    it = linearInstances_.begin();
    end = linearInstances_.end();
  }
  else
  {
    it = nonlinearInstances_.begin();
    end = nonlinearInstances_.end();
  }

  for ( ; it != end; ++it )
  {
    Instance & vi = *(*it);

    // Get the value for the source.
    SourceData *dataPtr  = vi.dcSourceData_; // by default assume the DC value.
    if ((HBSpecified_ || getSolverState().tranopFlag || getSolverState().transientFlag || (ACSpecified_ && !vi.DCSOURCETYPEgiven ) ) && vi.tranSourceData_ != 0 )
    {
      dataPtr            = vi.tranSourceData_;
    }

    if (dataPtr != 0)
    {
      vi.srcBC           = dataPtr->returnSource();
    }
    else
    {
      vi.srcBC           = 0.0;
    }

    vi.srcCurrent        = solVec[vi.li_Bra];
    vi.srcDrop           = (solVec[vi.li_Pos]-solVec[vi.li_Neg]);

    if( vi.PORTgiven && !getSolverState().spAnalysisFlag_ ) 
      vi.srcDrop  -= vi.srcCurrent * vi.Z0;

    fVec[vi.li_Pos] += vi.srcCurrent;
    fVec[vi.li_Neg] += -vi.srcCurrent;
    fVec[vi.li_Bra] += vi.srcDrop;

    bVec[vi.li_Bra] += vi.srcBC;

    if( vi.loadLeadCurrent )
    {
      leadF[vi.li_branch_data] = vi.srcCurrent;
      junctionV[vi.li_branch_data] = vi.srcDrop;
    }

  }
  return true;
}

//-----------------------------------------------------------------------------
// Function      : Master::loadDAEMatrices
// Purpose       :
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL
// Creation Date : 11/26/08
//-----------------------------------------------------------------------------
bool Master::loadDAEMatrices (Linear::Matrix & dFdx, Linear::Matrix & dQdx, int loadType)
{
  InstanceVector::const_iterator it, end;

  if (loadType == LINEAR_FREQ)
    loadType = LINEAR;

  if (!separateInstances_ && ( loadType == LINEAR || loadType == NONLINEAR ))
  {
    separateInstanceTypes(linearInstances_, nonlinearInstances_);
    separateInstances_ = true;
  }

  if (loadType == ALL)
  {
    it = getInstanceBegin();
    end = getInstanceEnd();
  }
  else if (loadType == LINEAR)
  {
    it = linearInstances_.begin();
    end = linearInstances_.end();
  }
  else
  {
    it = nonlinearInstances_.begin();
    end = nonlinearInstances_.end();
  }

  for ( ; it != end; ++it )
  {
    Instance & vi = *(*it);

#ifndef Xyce_NONPOINTER_MATRIX_LOAD
    *(vi.fPosEquBraVarPtr) += 1.0;
    *(vi.fNegEquBraVarPtr) -= 1.0;
    *(vi.fBraEquPosNodePtr) += 1.0;
    *(vi.fBraEquNegNodePtr) -= 1.0;

    if( vi.PORTgiven && !getSolverState().spAnalysisFlag_ )
      *(vi.fBraEquBraVarPtr) -= vi.Z0;

#else
    dFdx[vi.li_Pos][vi.APosEquBraVarOffset] += 1.0;
    dFdx[vi.li_Neg][vi.ANegEquBraVarOffset] -= 1.0;
    dFdx[vi.li_Bra][vi.ABraEquPosNodeOffset] += 1.0;
    dFdx[vi.li_Bra][vi.ABraEquNegNodeOffset] -= 1.0;

    if( vi.PORTgiven && !getSolverState().spAnalysisFlag_ ) 
      dFdx[vi.li_Bra][vi.ABraEquBraVarOffset] -= vi.Z0;

#endif
  }
  return true;
}

Device *
Traits::factory(const Configuration &configuration, const FactoryBlock &factory_block)
{
  return new Master(configuration, factory_block, factory_block.solverState_, factory_block.deviceOptions_);
}

void
registerDevice(const DeviceCountMap& deviceMap, const std::set<int>& levelSet)
{
  if (deviceMap.empty() || (deviceMap.find("V")!=deviceMap.end())  || (deviceMap.find("P")!=deviceMap.end() ) )
  {
    Config<Traits>::addConfiguration()
      .registerDevice("v", 1)
      .registerDevice("p", 1);

  }
}


//-----------------------------------------------------------------------------
// Function      : dcVsrcSensitivity::operator
// Purpose       : produces df/dp and dq/dp, where p=DCV0.
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL
// Creation Date : 7/18/2014
//-----------------------------------------------------------------------------
void dcVsrcSensitivity::operator()(
    const ParameterBase &entity,
    const std::string & name,
    std::vector<double> & dfdp,
    std::vector<double> & dqdp,
    std::vector<double> & dbdp,
    std::vector<int> & Findices,
    std::vector<int> & Qindices,
    std::vector<int> & Bindices
    ) const
{
  const ParameterBase * e1 = &entity;
  const Instance * in = dynamic_cast<const Instance *> (e1);

  dbdp.resize(1);
  dbdp[0] += 1.0;
  Bindices.resize(1);
  Bindices[0] = in->li_Bra;
}

//-----------------------------------------------------------------------------
// Function      : acMagVsrcSensitivity::operator
// Purpose       : B-vector sensitivities w.r.t. Mag parameter
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL
// Creation Date : 4/1/2019
//-----------------------------------------------------------------------------
void acMagVsrcSensitivity::operator()(
    const ParameterBase &entity,
    const std::string & name,
    std::vector< std::complex<double> > & dbdp,
    std::vector<int> & Bindices
    ) const
{
  const ParameterBase * e1 = &entity;
  const Instance * in = dynamic_cast<const Instance *> (e1);

  double mpi = M_PI;
  double phase = in->ACPHASE;
  double realpart=std::cos(2.0*mpi*phase/360);
  double imagpart=std::sin(2.0*mpi*phase/360);

  dbdp.resize(1);
  dbdp[0] += std::complex<double> (realpart,imagpart);
  Bindices.resize(1);
  Bindices[0] = in->li_Bra;
}

//-----------------------------------------------------------------------------
// Function      : acPhaseVsrcSensitivity::operator
// Purpose       : B-vector sensitivities w.r.t. Phase parameter
// Special Notes :
// Scope         : public
// Creator       : Eric Keiter, SNL
// Creation Date : 4/1/2019
//-----------------------------------------------------------------------------
void acPhaseVsrcSensitivity::operator()(
    const ParameterBase &entity,
    const std::string & name,
    std::vector< std::complex<double> > & dbdp,
    std::vector<int> & Bindices
    ) const
{
  const ParameterBase * e1 = &entity;
  const Instance * in = dynamic_cast<const Instance *> (e1);
  double mpi = M_PI;
  double mag = in->ACMAG;
  double phase = in->ACPHASE;
  double realpart= -(2.0*mpi*mag*std::sin(2.0*mpi*phase/360))/360;
  double imagpart= +(2.0*mpi*mag*std::cos(2.0*mpi*phase/360))/360;

  dbdp.resize(1);
  dbdp[0] += std::complex<double> (realpart, imagpart);
  Bindices.resize(1);
  Bindices[0] = in->li_Bra;
}

} // namespace Vsrc
} // namespace Device
} // namespace Xyce
src/DeviceModelPKG/OpenModels/N_DEV_Vsrc.h0000666000175000017500000003037713656722377016621 0ustar  dkcdkc//-------------------------------------------------------------------------
//   Copyright 2002-2020 National Technology & Engineering Solutions of
//   Sandia, LLC (NTESS).  Under the terms of Contract DE-NA0003525 with
//   NTESS, the U.S. Government retains certain rights in this software.
//
//   This file is part of the Xyce(TM) Parallel Electrical Simulator.
//
//   Xyce(TM) 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 3 of the License, or
//   (at your option) any later version.
//
//   Xyce(TM) 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 Xyce(TM).
//   If not, see <http://www.gnu.org/licenses/>.
//-------------------------------------------------------------------------

//-----------------------------------------------------------------------------
//
// Purpose        : Independent voltage source classes.
//
// Special Notes  :
//
// Creator        : Eric R. Keiter, SNL, Parallel Computational Sciences
//
// Creation Date  : 02/28/00
//
//
//
//
//-----------------------------------------------------------------------------

#ifndef Xyce_N_DEV_Vsrc_h
#define Xyce_N_DEV_Vsrc_h

// ----------   Xyce Includes   ----------
#include <N_DEV_Configuration.h>
#include <N_DEV_DeviceMaster.h>
#include <N_DEV_Source.h>
#include <N_DEV_DeviceBlock.h>
#include <N_DEV_DeviceInstance.h>
#include <N_DEV_DeviceModel.h>

namespace Xyce {
namespace Device {
namespace Vsrc {

class Model;
class Instance;

/// sensitivity functors
class dcVsrcSensitivity :  public baseSensitivity
{
  public:
  dcVsrcSensitivity() : 
    baseSensitivity() {};

  virtual ~dcVsrcSensitivity() {};

  virtual void operator()(
    const ParameterBase &entity,
    const std::string &name,
    std::vector<double> & dfdp, 
    std::vector<double> & dqdp, 
    std::vector<double> & dbdp, 
    std::vector<int> & Findices,
    std::vector<int> & Qindices,
    std::vector<int> & Bindices
    ) const ;
};

class acMagVsrcSensitivity :  public baseACSensitivity
{
  public:
  acMagVsrcSensitivity() : 
    baseACSensitivity() {};

  virtual ~acMagVsrcSensitivity() {};

  virtual void operator()(
    const ParameterBase &entity,
    const std::string &name,
    std::vector< std::complex<double> > & dbdp, 
    std::vector<int> & Bindices
    ) const ;
};

class acPhaseVsrcSensitivity :  public baseACSensitivity
{
  public:
  acPhaseVsrcSensitivity() : 
    baseACSensitivity() {};

  virtual ~acPhaseVsrcSensitivity() {};

  virtual void operator()(
    const ParameterBase &entity,
    const std::string &name,
    std::vector< std::complex<double> > & dbdp, 
    std::vector<int> & Bindices
    ) const ;
};

static dcVsrcSensitivity dcv0Sens;
static acMagVsrcSensitivity acMagSens;
static acPhaseVsrcSensitivity acPhaseSens;

struct Traits : public DeviceTraits<Model, Instance>
{
  static const char *name() {return "Independent Voltage Source";}
  static const char *deviceTypeName() {return "V level 1";}
  static ParametricData<Instance> &instanceParameters();

  static int numNodes() {return 2;}
  static const char *primaryParameter() {return "DCV0";}
  static const char *instanceDefaultParameter() {return "DCV0";}
  static bool isLinearDevice() {return true;}

  static Device *factory(const Configuration &configuration, const FactoryBlock &factory_block);
  static void loadModelParameters(ParametricData<Model> &model_parameters);
  static void loadInstanceParameters(ParametricData<Instance> &instance_parameters);
  static ParametricData<Model> &modelParameters();
};

//-----------------------------------------------------------------------------
// Class         : Instance
// Purpose       :
// Special Notes :
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 04/06/00
//-----------------------------------------------------------------------------
class Instance : public SourceInstance
{
  friend class ParametricData<Instance>;
  friend class Model;
  friend struct Traits;
  friend class Master;
  friend class dcVsrcSensitivity;
  friend class acMagVsrcSensitivity;
  friend class acPhaseVsrcSensitivity;

public:
  Instance(
     const Configuration &       configuration,
     const InstanceBlock &       IB,
     Model &                     Viter,
     const FactoryBlock &        factory_block);

  Instance(const Instance & right);
  ~Instance();

  bool isLinearDevice() const 
  { 
    if (loadLeadCurrent)
    {
      return false;
    }
    return true; 
  }

  void registerLIDs( const std::vector<int> & intLIDVecRef,
                     const std::vector<int> & extLIDVecRef );
  void registerStateLIDs( const std::vector<int> & staLIDVecRef );
  void registerBranchDataLIDs(const std::vector<int> & branchLIDVecRef);

  void loadNodeSymbols(Util::SymbolTable &symbol_table) const; // override

  const std::vector< std::vector<int> > & jacobianStamp() const;
  void registerJacLIDs( const std::vector< std::vector<int> > & jacLIDVec );

  bool processParams ();

  bool updateIntermediateVars () { return true; }
  bool updatePrimaryState () { return true; }

  // load functions, residual:
  bool loadBVectorsforAC (double * bVecReal, double * bVecImag);
  bool loadDAEQVector () { return true; }
  bool loadDAEFVector ();
  bool loadDAEBVector ();

  // load functions, Jacobian:
  bool loadDAEdQdx () { return true; }
  bool loadDAEdFdx ();

  void setupPointers();

  double getMaxTimeStepSize ();
  virtual bool maxTimeStepSupported () {return true;};

  void varTypes( std::vector<char> & varTypeVec );

  void getLIDs(int & lpos, int & lneg,int & lbra)
  {lpos = li_Pos; lneg = li_Neg; lbra = li_Bra;}

  double getZ0()  {return Z0; }

  int getPort()  {return port; }

  bool isPortSpecified()  {return PORTgiven;}

public:
  // iterator reference to the vsrc model which owns this instance.
  // Getters and setters
  Model &getModel() 
  {
    return model_;
  }

private:

  Model &       model_;         //< Owning model

  // state variables:
  double srcCurrent;
  double srcDrop;
  double srcBC;

  bool          HBSpecified_;
  bool          ACSpecified_;

  // Parameters
  double DCV0;
  double par0;
  double par1;
  double par2;
  double par3;
  double par4;
  double par5;
  double par6;
  double REPEATTIME;
  double T;
  double V;
  double ACMAG;
  double ACPHASE;

  std::string DATA;
  int RB;
  int NUM;
  bool REPEAT;
  int TRANSIENTSOURCETYPE;
  bool TRANSIENTSOURCETYPEgiven;
  int ACSOURCETYPE;
  bool ACSOURCETYPEgiven;
  int DCSOURCETYPE;
  bool DCSOURCETYPEgiven;
  bool gotParams;

  // load variables
  double source, v_pos, v_neg, i_bra;

  // indices into state vector:
  int istate_I;  // index for i0;

  // Matrix equation index variables:

  //local indices (offsets)
  int li_Pos;
  int li_Neg;
  int li_Bra;
  int li_branch_data;         ///< Index for Lead Current and junction voltage (for power calculations)

  // Jacobian matrix indices:
  //Locally indexed offsets for jacobian
  int ABraEquPosNodeOffset; // Offset, pos. node voltage contribution,
  // branch current equ.

  int ABraEquNegNodeOffset; // Offset, neg. node voltage contribution,
  // branch current equ.

  int APosEquBraVarOffset;  // Offset, branch current variable
  // contribution, KCL equation of the pos node

  int ANegEquBraVarOffset;  // Offset, branch current variable
  // contribution, KCL equation of the neg node

  //  The following jacobian offsets are only neccessary
  // for 2-level newton.
  int APosEquPosNodeOffset;  // Offset, positive node variable
  // contribution, positive node KCL.

  int ANegEquNegNodeOffset;  // Offset, negative node variable
  // contribution, negative node KCL.

  int ABraEquBraVarOffset;  // Offset, branch current variable
  // contribution, branch current equation.

#ifndef Xyce_NONPOINTER_MATRIX_LOAD
  // Jacobian matrix pointers:
  double * fBraEquPosNodePtr;
  double * fBraEquNegNodePtr;
  double * fPosEquBraVarPtr;
  double * fNegEquBraVarPtr;

  //  The following jacobian pointers are only neccessary for 2-level newton.
  double * fPosEquPosNodePtr;
  double * fNegEquNegNodePtr;
  double * fBraEquBraVarPtr;
#endif

  static std::vector< std::vector<int> > jacStamp;
  static std::vector< std::vector<int> > jacStampPDE;

  int port;
  double Z0;

  bool PORTgiven;
  bool Z0given;

public:
  inline int liPos() const {return li_Pos;}
  inline int liNeg() const {return li_Neg;}

  inline const ExternData *extDataPtr() const {return &extData;} 
};

//-----------------------------------------------------------------------------
// Class         : Model
// Purpose       :
// Special Notes :
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 04/06/00
//-----------------------------------------------------------------------------
class Model : public DeviceModel
{
  typedef std::vector<Instance *> InstanceVector;

  friend class ParametricData<Model>;
  friend class Instance;
  friend struct Traits;
  friend class Master;
  friend class dcVsrcSensitivity;
  friend class acMagVsrcSensitivity;
  friend class acPhaseVsrcSensitivity;

public:
  Model(
     const Configuration &       configuration,
     const ModelBlock &        MB,
     const FactoryBlock &      factory_block);
  ~Model ();

private:
  Model();
  Model(const Model &);
  Model &operator=(const Model &);

public:
  virtual void forEachInstance(DeviceInstanceOp &op) const /* override */;

  virtual std::ostream &printOutInstances(std::ostream &os) const;
  virtual bool processParams() 
  {
    return true;
  }

  virtual bool processInstanceParams() 
  {
    return true;
  }


public:
  void addInstance(Instance *instance) 
  {
    instanceContainer.push_back(instance);
  }

  void setupBaseInstanceContainer()
  {
    std::vector<Instance*>::iterator iter = instanceContainer.begin();
    std::vector<Instance*>::iterator end   = instanceContainer.end();
    for ( ; iter!=end; ++iter)
    {
      Xyce::Device::DeviceModel::baseInstanceContainer.push_back( static_cast<Xyce::Device::DeviceInstance *>(*iter) );
    }
  }

private:
  std::vector<Instance*> instanceContainer;

private:

  // This is the dc and transient analysis value of the source.
  double DC_TRAN;
};

//-----------------------------------------------------------------------------
// Class         : Master
// Purpose       :
// Special Notes :
// Creator       : Eric Keiter, SNL, Parallel Computational Sciences
// Creation Date : 11/26/08
//-----------------------------------------------------------------------------
class Master : public DeviceMaster<Traits>
{
  friend class Instance;
  friend class Model;

public:
  Master(
    const Configuration &       configuration,
    const FactoryBlock &        factory_block,
    const SolverState &         solver_state,
    const DeviceOptions &       device_options);

  virtual bool updateState (double * solVec, double * staVec, double * stoVec) { return true; }
  virtual bool updateSecondaryState (double * staDerivVec, double * stoVec) { return true; }

  // load functions:
  virtual bool loadDAEVectors (double * solVec, double * fVec, double * qVec, double * bVec,
                               double * leadF, double * leadQ, double * junctionV)
    { return loadDAEVectors( solVec, fVec, qVec, bVec, leadF, leadQ, junctionV, ALL ); }
  virtual bool loadDAEVectors (double * solVec, double * fVec, double * qVec, double * bVec,
                               double * leadF, double * leadQ, double * junctionV, int loadType);

  virtual bool loadDAEMatrices(Linear::Matrix & dFdx, Linear::Matrix & dQdx)
    { return loadDAEMatrices( dFdx, dQdx, ALL ); }
  virtual bool loadDAEMatrices(Linear::Matrix & dFdx, Linear::Matrix & dQdx, int loadType);

private:
  bool          HBSpecified_;
  bool          ACSpecified_;
  bool separateInstances_;
  InstanceVector      linearInstances_;            ///< List of owned linear voltage source instances
  InstanceVector      nonlinearInstances_;         ///< List of owned nonlinear voltage source instances
};

void registerDevice(const DeviceCountMap& deviceMap, const std::set<int>& levelSet);

} // namespace Vsrc
} // namespace Device
} // namespace Xyce

#endif
src/UtilityPKG/0000777000175000017500000000000013654372532011754 5ustar  dkcdkcsrc/UtilityPKG/CMakeLists.txt0000666000175000017500000000576213654372532014526 0ustar  dkcdkc
# -- process files for this library ------------------------------------------


# process source file options
if ( Xyce_USE_INTEL_FFT )
  set ( FFT_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_IntelFFT_Interface.C )
endif ( Xyce_USE_INTEL_FFT )

if ( Xyce_USE_FFTW )
  set ( FFTW_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_FFTW_Interface.C )
endif ( Xyce_USE_FFTW )


# class source list
set ( Utility_SOURCES
      ${FFT_SOURCES}
      ${FFTW_SOURCES}
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_BreakPoint.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_Demangle.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_DeviceNameConverters.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_Diagnostic.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_Expression.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_ExpressionData.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_ExpressionInternals.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_APFT.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_FFTInterface.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_LogStream.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_Misc.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_MathSpecialFunctions.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_ExtendedString.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_NoCase.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_Op.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_OpBuilder.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_OptionBlock.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_OutputAPIHelpers.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_Param.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_Marshal.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_JSON.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_SendCURL.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_RandomNumbers.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_ReportHandler.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_RFparams.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_Timer.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_CPUTime.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_MallocUsed.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_FormatMemorySize.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_FormatTime.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_StatMetricTraits.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_Stats.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_Platform.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_PrintStats.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_PrintTable.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_WallTime.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_Version.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_NameLevelKey.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_NetlistLocation.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_NodeSymbols.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_CheckIfValidFile.C
      ${CMAKE_CURRENT_SOURCE_DIR}/N_UTL_CheckIfValidURI.C
      CACHE INTERNAL "X_S" )


# add header files to project
set ( XYCE_INCLUDE_DIRECTORIES ${XYCE_INCLUDE_DIRECTORIES}
      ${CMAKE_CURRENT_SOURCE_DIR}
      CACHE INTERNAL "X_I" )




# -- build requested libraries -----------------------------------------------
set ( XYCE_PACKAGE_LIBRARIES ${XYCE_PACKAGE_LIBRARIES}
      Utility
      CACHE INTERNAL "X_L" )
src/UtilityPKG/Makefile.am0000666000175000017500000000650213654372532014013 0ustar  dkcdkc
AM_CPPFLAGS = @Xyce_INCS@ -DXYCEBUILDTIMESTAMP=\"`$(top_srcdir)/utils/XyceDatestamp.sh $(top_srcdir)`\"

noinst_LTLIBRARIES = libUtility.la

if BUILD_INTEL_FFT_SUPPORT
intelfft_SOURCES = \
  N_UTL_IntelFFT_Interface.C \
  N_UTL_IntelFFT_Interface.hpp
else
intelfft_SOURCES =
endif

if BUILD_FFTW_SUPPORT
fftw_SOURCES = \
  N_UTL_FFTW_Interface.C \
  N_UTL_FFTW_Interface.hpp
else
fftw_SOURCES =
endif

if THREADS 
threads_LIB = -lpthread 
threads_CFLAGS = -pthread 
else 
threads_LIB = 
threads_CFLAGS = 
endif 

libUtility_la_SOURCES = \
  $(intelfft_SOURCES) \
  $(fftw_SOURCES) \
  N_UTL_BreakPoint.C \
  N_UTL_Demangle.C \
  N_UTL_DeviceNameConverters.C \
  N_UTL_Diagnostic.C \
  N_UTL_NoCase.C \
  N_UTL_Expression.C \
  N_UTL_ExpressionData.C \
  N_UTL_ExpressionInternals.C \
  N_UTL_APFT.C \
  N_UTL_FFTInterface.C \
  N_UTL_LogStream.C \
  N_UTL_ReportHandler.C \
  N_UTL_Marshal.C \
  N_UTL_JSON.C \
  N_UTL_SendCURL.C \
  N_UTL_ByThreadStreambuf.C \
  N_UTL_Misc.C \
  N_UTL_ExtendedString.C \
  N_UTL_NetlistLocation.C \
  N_UTL_NodeSymbols.C \
  N_UTL_OptionBlock.C \
  N_UTL_Op.C \
  N_UTL_OpBuilder.C \
  N_UTL_OutputAPIHelpers.C \
  N_UTL_Param.C \
  N_UTL_RandomNumbers.C \
  N_UTL_RFparams.C \
  N_UTL_Timer.C \
  N_UTL_CPUTime.C \
  N_UTL_MallocUsed.C \
  N_UTL_FormatMemorySize.C \
  N_UTL_FormatTime.C \
  N_UTL_StatMetricTraits.C \
  N_UTL_Stats.C \
  N_UTL_Platform.C \
  N_UTL_PrintTable.C \
  N_UTL_PrintStats.C \
  N_UTL_WallTime.C \
  N_UTL_Version.C \
  N_UTL_Algorithm.C \
  N_UTL_NameLevelKey.C \
  N_UTL_CheckIfValidFile.C \
  N_UTL_CheckIfValidURI.C \
  N_UTL_MathSpecialFunctions.C \
  N_UTL_AssemblyTypes.h \
  N_UTL_TypeIndex.h \
  N_UTL_NameLevelKey.h \
  N_UTL_DeleteList.h \
  N_UTL_Interface_Enum_Types.h \
  N_UTL_Interpolators.h \
  N_UTL_ExpressionSymbolTable.h \
  N_UTL_Expression.h \
  N_UTL_ExpressionInternals.h \
  N_UTL_ExpressionData.h \
  N_UTL_FFTInterface.hpp \
  N_UTL_RandomNumbers.h \
  N_UTL_RFparams.h \
  N_UTL_Demangle.h \
  N_UTL_DeviceNameConverters.h \
  N_UTL_Diagnostic.h \
  N_UTL_IndentStreamBuf.h \
  N_UTL_TeeStreamBuf.h \
  N_UTL_PThread.h \
  N_UTL_ByThreadStreambuf.h \
  N_UTL_LogStream.h \
  N_UTL_ReportHandler.h \
  N_UTL_Marshal.h \
  N_UTL_JSON.h \
  N_UTL_SendCURL.h \
  N_UTL_Op.h \
  N_UTL_OpBuilder.h \
  N_UTL_OutputAPIHelpers.h \
  N_UTL_APFT.h \
  N_UTL_DFTInterfaceDecl.hpp \
  N_UTL_FFTInterfaceDecl.hpp \
  N_UTL_FixedQueue.h \
  N_UTL_Functors.h \
  N_UTL_MachDepParams.h \
  N_UTL_Listener.h \
  N_UTL_Dump.h \
  N_UTL_Misc.h \
  N_UTL_ExtendedString.h \
  N_UTL_NetlistLocation.h \
  N_UTL_NodeSymbols.h \
  N_UTL_SaveIOSState.h \
  N_UTL_BreakPoint.h \
  N_UTL_Factory.h \
  N_UTL_OptionBlock.h \
  N_UTL_Pack.h \
  N_UTL_Param.h \
  N_UTL_Timer.h \
  N_UTL_CPUTime.h \
  N_UTL_FormatMemorySize.h \
  N_UTL_FormatTime.h \
  N_UTL_MallocUsed.h \
  N_UTL_StatMetricTraits.h \
  N_UTL_Stats.h \
  N_UTL_Platform.h \
  N_UTL_PrintStats.h \
  N_UTL_PrintTable.h \
  N_UTL_WallTime.h \
  N_UTL_Graph.h \
  N_UTL_Xyce.h \
  N_UTL_FeatureTest.h \
  N_UTL_IndentStreamBuf.h \
  N_UTL_NoCase.h \
  N_UTL_Version.h \
  N_UTL_Algorithm.h \
  N_UTL_CheckIfValidFile.h \
  N_UTL_CheckIfValidURI.h \
  N_UTL_Math.h \
  N_UTL_MathSpecialFunctions.h 

BUILT_SOURCES = timestamp-generator

CLEANFILES = timestamp.h

timestamp.h: timestamp-generator

timestamp-generator:
	echo "/* TIMESTAMP APPLIED */" > timestamp.h

src/UtilityPKG/N_UTL_CheckIfValidURI.C0000666000175000017500000000411213654372532015713 0ustar  dkcdkc//-------------------------------------------------------------------------
//   Copyright 2002-2020 National Technology & Engineering Solutions of
//   Sandia, LLC (NTESS).  Under the terms of Contract DE-NA0003525 with
//   NTESS, the U.S. Government retains certain rights in this software.
//
//   This file is part of the Xyce(TM) Parallel Electrical Simulator.
//
//   Xyce(TM) 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 3 of the License, or
//   (at your option) any later version.
//
//   Xyce(TM) 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 Xyce(TM).
//   If not, see <http://www.gnu.org/licenses/>.
//-------------------------------------------------------------------------

#include <Xyce_config.h>

#include <fstream>
#include <string>

#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
// Windows is a Special Case, and stat.h does not define this macro.
#ifndef S_ISREG
#ifdef _S_IFREG
#define S_ISREG(mode) (((mode) & _S_IFMT) == _S_IFREG)
#else
#error stat.h missing S_ISREG and _S_IFREG.  Cannot proceed
#endif
#endif
#endif

namespace Xyce{
namespace Util {

//-----------------------------------------------------------------------------
// Function      : checkIfValidURI
// Purpose       : Verify that a user-specified URI is valid.
// Special Notes : This may only do a syntax check.
// Creator       : Kevin Cameron
// Creation Date : 04/22/2020
//-----------------------------------------------------------------------------

bool checkIfValidURI(std::string netlist_urispec)
{
  bool isValidURI = false;

  if (0 == netlist_urispec.find("code:")) {
      // Shared library, and entry-point
    isValidURI = true;
  }

  return isValidURI;
}

} // namespace Util
} // namespace Xyce
src/UtilityPKG/N_UTL_CheckIfValidURI.h0000666000175000017500000000264713654372532015773 0ustar  dkcdkc//-------------------------------------------------------------------------
//   Copyright 2002-2020 National Technology & Engineering Solutions of
//   Sandia, LLC (NTESS).  Under the terms of Contract DE-NA0003525 with
//   NTESS, the U.S. Government retains certain rights in this software.
//
//   This file is part of the Xyce(TM) Parallel Electrical Simulator.
//
//   Xyce(TM) 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 3 of the License, or
//   (at your option) any later version.
//
//   Xyce(TM) 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 Xyce(TM).
//   If not, see <http://www.gnu.org/licenses/>.
//-------------------------------------------------------------------------

#ifndef Xyce_N_UTL_CheckIfValidURI_h
#define Xyce_N_UTL_CheckIfValidURI_h

#include <string>

namespace Xyce {
namespace Util {

  enum URItype {
    URITYPE_NONE = 0, // Unrecognized
    URITYPE_CODE
  }; 

  bool checkIfValidURI(std::string netlist_urispec);

} // namespace Util
} // namespace Xyce

#endif // Xyce_N_UTL_CheckIfValidURI_h