ext/dsent/tech/TechModel.cc - testing/jenkins-gem5-prod - Git at Google

 /* Copyright (c) 2012 Massachusetts Institute of Technology
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
  * in the Software without restriction, including without limitation the rights
  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  * copies of the Software, and to permit persons to whom the Software is
  * furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be included in
  * all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */

 #include "tech/TechModel.h"

 #include <cmath>

 #include "model/std_cells/StdCellLib.h"

 namespace DSENT
 {
     TechModel::TechModel()
         : m_std_cell_lib_(NULL), m_available_wire_layers_(NULL)
     {}

     TechModel::~TechModel()
     {}

     const String& TechModel::get(const String &key_) const
     {
         return params.at(key_);
     }

     void TechModel::setStdCellLib(const StdCellLib* std_cell_lib_)
     {
         m_std_cell_lib_ = std_cell_lib_;
         return;
     }

     const StdCellLib* TechModel::getStdCellLib() const
     {
         return m_std_cell_lib_;
     }

     TechModel* TechModel::clone() const
     {
         return new TechModel(*this);
     }

     void TechModel::readFile(const String& filename_)
     {
         // Read the main technology file
         LibUtil::readFile(filename_, params);

         // Search for "INCLUDE" to include more technology files
         for (const auto &it : params)
         {
             const String& key = it.first;
             if(key.compare(0, 8, "INCLUDE_") == 0)
             {
                 const String& include_filename = it.second;
                 LibUtil::readFile(include_filename, params);
             }
         }

         // Set the available wire layers
         const vector<String>& available_wire_layer_vector = get("Wire->AvailableLayers").split("[,]");
         m_available_wire_layers_ = new std::set<String>;
         for(unsigned int i = 0; i < available_wire_layer_vector.size(); ++i)
         {
             m_available_wire_layers_->insert(available_wire_layer_vector[i]);
         }
     }

     //-------------------------------------------------------------------------
     // Transistor Related Functions
     //-------------------------------------------------------------------------
     //Returns the leakage current of NMOS transistors, given the transistor stakcing, transistor widths, and input combination
     double TechModel::calculateNmosLeakageCurrent(unsigned int num_stacks_, double uni_stacked_mos_width_, unsigned int input_vector_) const
     {
         vector<double> stacked_mos_widths_(num_stacks_, uni_stacked_mos_width_);
         return calculateNmosLeakageCurrent(num_stacks_, stacked_mos_widths_, input_vector_);
     }

     //Returns the leakage current of NMOS transistors, given the transistor stakcing, transistor widths, and input combination
     double TechModel::calculateNmosLeakageCurrent(unsigned int num_stacks_, const vector<double>& stacked_mos_widths_, unsigned int input_vector_) const
     {
         // Get technology parameters
         double vdd = get("Vdd");
         double temp = get("Temperature");
         double char_temp = get("Nmos->CharacterizedTemperature");
         double min_off_current = get("Nmos->MinOffCurrent");
         double off_current = get("Nmos->OffCurrent");
         double subthreshold_swing = get("Nmos->SubthresholdSwing");
         double dibl = get("Nmos->DIBL");
         double temp_swing = get("Nmos->SubthresholdTempSwing");

         // Map dibl to a swing value for easier calculation
         double dibl_swing = subthreshold_swing / dibl;

         //Calculate the leakage current factor
         double leakage_current_factor = calculateLeakageCurrentFactor(num_stacks_, stacked_mos_widths_, input_vector_, vdd, subthreshold_swing, dibl_swing);

         // Calcualte actual leakage current at characterized temperature
         double leakage_current_char_tmp = stacked_mos_widths_[0] * off_current * std::pow(10.0, leakage_current_factor);
         leakage_current_char_tmp = std::max(min_off_current, leakage_current_char_tmp);

         // Calculate actual leakage current at temp
         double leakage_current = leakage_current_char_tmp * std::pow(10.0, (temp - char_temp) / temp_swing);

         return leakage_current;
     }

     double TechModel::calculatePmosLeakageCurrent(unsigned int num_stacks_, double uni_stacked_mos_width_, unsigned int input_vector_) const
     {
         vector<double> stacked_mos_widths_(num_stacks_, uni_stacked_mos_width_);
         return calculatePmosLeakageCurrent(num_stacks_, stacked_mos_widths_, input_vector_);
     }

     //Returns the leakage current of PMOS transistors, given the transistor stakcing, transistor widths, and input combination
     double TechModel::calculatePmosLeakageCurrent(unsigned int num_stacks_, const vector<double>& stacked_mos_widths_, unsigned int input_vector_) const
     {
         // Get technology parameters
         double vdd = get("Vdd");
         double temp = get("Temperature");
         double char_temp = get("Pmos->CharacterizedTemperature");
         double min_off_current = get("Pmos->MinOffCurrent");
         double off_current = get("Pmos->OffCurrent");
         double dibl = get("Pmos->DIBL");
         double subthreshold_swing = get("Pmos->SubthresholdSwing");
         double temp_swing = get("Nmos->SubthresholdTempSwing");

         // Map dibl to a swing value for easier calculation
         double dibl_swing = subthreshold_swing / dibl;

         //Calculate the leakage current factor
         double leakage_current_factor = calculateLeakageCurrentFactor(num_stacks_, stacked_mos_widths_, input_vector_, vdd, subthreshold_swing, dibl_swing);

         // Calcualte actual leakage current at characterized temperature
         double leakage_current_char_tmp = stacked_mos_widths_[0] * off_current * std::pow(10.0, leakage_current_factor);
         leakage_current_char_tmp = std::max(min_off_current, leakage_current_char_tmp);

         // Calculate actual leakage current at temp
         double leakage_current = leakage_current_char_tmp * std::pow(10.0, (temp - char_temp) / temp_swing);

         return leakage_current;
     }

     //Returns the leakage current, given the transistor stakcing, transistor widths, input combination,
     //and technology information (vdd, subthreshold swing, subthreshold dibl swing)
     double TechModel::calculateLeakageCurrentFactor(unsigned int num_stacks_, const vector<double>& stacked_mos_widths_, unsigned int input_vector_, double vdd_, double subthreshold_swing_, double dibl_swing_) const
     {
         // check everything is valid
         ASSERT(num_stacks_ >= 1, "[Error] Number of stacks must be >= 1!");
         ASSERT(stacked_mos_widths_.size() == num_stacks_, "[Error] Mismatch in number of stacks and the widths specified!");

         //Use short name in this method
         const double s1 = subthreshold_swing_;
         const double s2 = dibl_swing_;

         // Decode input combinations from input_vector_
         std::vector<double> vs(num_stacks_, 0.0);
         for(int i = 0; i < (int)num_stacks_; ++i)
         {
             double current_input = (double(input_vector_ & 0x1))*vdd_;
             vs[i] = (current_input);
             input_vector_ >>= 1;
         }
         // If the widths pointer is NULL, width is set to 1 by default
         vector<double> ws = stacked_mos_widths_;

         //Solve voltages at internal nodes of stacked transistors
         // v[0] = 0
         // v[num_stacks_] = vdd_
         // v[i] = (1.0/(2*s1 + s2))*((s1 + s2)*v[i - 1] + s1*v[i + 1]
         //                 + s2*(vs[i + 1] - vs[i]) + s1*s2*log10(ws[i + 1]/ws[i]))
         //Use tri-matrix solver to solve the above linear system

         double A = -(s1 + s2);
         double B = 2*s1 + s2;
         double C = -s1;
         std::vector<double> a(num_stacks_ - 1, 0);
         std::vector<double> b(num_stacks_ - 1, 0);
         std::vector<double> c(num_stacks_ - 1, 0);
         std::vector<double> d(num_stacks_ - 1, 0);
         std::vector<double> v(num_stacks_ + 1, 0);
         unsigned int eff_num_stacks = num_stacks_;
         bool is_found_valid_v = false;
         do
         {
             //Set boundary condition
             v[0] = 0;
             v[eff_num_stacks] = vdd_;

             //If the effective number of stacks is 1, no matrix needs to be solved
             if(eff_num_stacks == 1)
             {
                 break;
             }

             //----------------------------------------------------------------------
             //Setup the tri-matrix
             //----------------------------------------------------------------------
             for(int i = 0; i < (int)eff_num_stacks-2; ++i)
             {
                 a[i + 1] = A;
                 c[i] = C;
             }
             for(int i = 0; i < (int)eff_num_stacks-1; ++i)
             {
                 b[i] = B;
                 d[i] = s2*(vs[i + 1] - vs[i]) + s1*s2*std::log10(ws[i + 1]/ws[i]);
                 if(i == ((int)eff_num_stacks - 2))
                 {
                     d[i] -= C*vdd_;
                 }
             }
             //----------------------------------------------------------------------

             //----------------------------------------------------------------------
             //Solve the tri-matrix
             //----------------------------------------------------------------------
             for(int i = 1; i < (int)eff_num_stacks-1; ++i)
             {
                 double m = a[i]/b[i - 1];
                 b[i] -= m*c[i - 1];
                 d[i] -= m*d[i - 1];
             }

             v[eff_num_stacks - 1] = d[eff_num_stacks - 2]/b[eff_num_stacks - 2];
             for(int i = eff_num_stacks - 3; i >= 0; --i)
             {
                 v[i + 1] = (d[i] - c[i]*v[i + 2])/b[i];
             }
             //----------------------------------------------------------------------

             //Check if the internal voltages are in increasing order
             is_found_valid_v = true;
             for(int i = 1; i <= (int)eff_num_stacks; ++i)
             {
                 //If the ith internal voltage is not in increasing order
                 //(i-1)th transistor is in triode region
                 //Remove the transistors in triode region as it does not exist
                 if(v[i] < v[i - 1])
                 {
                     is_found_valid_v = false;
                     eff_num_stacks--;
                     vs.erase(vs.begin() + i - 1);
                     ws.erase(ws.begin() + i - 1);
                     break;
                 }
             }
         } while(!is_found_valid_v);

         //Calculate the leakage current of the bottom transistor (first not in triode region)
         double vgs = vs[0] - v[0];
         double vds = v[1] - v[0];
         double leakage_current_factor = vgs/s1 + (vds - vdd_)/s2;
         //TODO - Check if the leakage current calculate for other transistors is identical

         return leakage_current_factor;
     }
     //-------------------------------------------------------------------------

     //-------------------------------------------------------------------------
     // Wire Related Functions
     //-------------------------------------------------------------------------
     bool TechModel::isWireLayerExist(const String& layer_name_) const
     {
         std::set<String>::const_iterator it;
         it = m_available_wire_layers_->find(layer_name_);
         return (it != m_available_wire_layers_->end());
     }

     const std::set<String>* TechModel::getAvailableWireLayers() const
     {
         return m_available_wire_layers_;
     }

     double TechModel::calculateWireCapacitance(const String& layer_name_, double width_, double spacing_, double length_) const
     {
         // Get technology parameter
         double min_width = get("Wire->" + layer_name_ + "->MinWidth").toDouble();
         double min_spacing = get("Wire->" + layer_name_ + "->MinSpacing").toDouble();
         double metal_thickness = get("Wire->" + layer_name_ + "->MetalThickness").toDouble();
         double dielec_thickness = get("Wire->" + layer_name_ + "->DielectricThickness").toDouble();
         double dielec_const = get("Wire->" + layer_name_ + "->DielectricConstant").toDouble();

         ASSERT(width_ >= min_width, "[Error] Wire width must be >= " + (String) min_width + "!");
         ASSERT(spacing_ >= min_spacing, "[Error] Wire spacing must be >= " + (String) min_spacing + "!");
         ASSERT(length_ >= 0, "[Error] Wire length must be >= 0!");

         double A, B, C;
         // Calculate ground capacitance
         A = width_ / dielec_thickness;
         B = 2.04*std::pow((spacing_ / (spacing_ + 0.54 * dielec_thickness)), 1.77);
         C = std::pow((metal_thickness / (metal_thickness + 4.53 * dielec_thickness)), 0.07);
         double unit_gnd_cap = dielec_const * 8.85e-12 * (A + B * C);

         A = 1.14 * (metal_thickness / spacing_) * std::exp(-4.0 * spacing_ / (spacing_ + 8.01 * dielec_thickness));
         B = 2.37 * std::pow((width_ / (width_ + 0.31 * spacing_)), 0.28);
         C = std::pow((dielec_thickness / (dielec_thickness + 8.96 * spacing_)), 0.76) *
                 std::exp(-2.0 * spacing_ / (spacing_ + 6.0 * dielec_thickness));
         double unit_coupling_cap = dielec_const * 8.85e-12 * (A + B * C);

         double total_cap = 2 * (unit_gnd_cap + unit_coupling_cap) * length_;
         return total_cap;
     }

     double TechModel::calculateWireResistance(const String& layer_name_, double width_, double length_) const
     {
         // Get technology parameter
         double min_width = get("Wire->" + layer_name_ + "->MinWidth");
         //double barrier_thickness = get("Wire->" + layer_name_ + "->BarrierThickness");
         double resistivity = get("Wire->" + layer_name_ + "->Resistivity");
         double metal_thickness = get("Wire->" + layer_name_ + "->MetalThickness");

         ASSERT(width_ >= min_width, "[Error] Wire width must be >= " + (String) min_width + "!");
         ASSERT(length_ >= 0, "[Error] Wire length must be >= 0!");

         // Calculate Rho
         // double rho = 2.202e-8 + (1.030e-15 / (width_ - 2.0 * barrier_thickness));

         double unit_res = resistivity / (width_ * metal_thickness);
         //double unit_res = rho / ((width_ - 2.0 * barrier_thickness) * (metal_thickness - barrier_thickness));

         double total_res = unit_res * length_;
         return total_res;
     }
     //-------------------------------------------------------------------------

     TechModel::TechModel(const TechModel& tech_model_)
         : m_std_cell_lib_(tech_model_.m_std_cell_lib_),
           params(tech_model_.params)
     {}
 } // namespace DSENT
	/* Copyright (c) 2012 Massachusetts Institute of Technology
	*
	* Permission is hereby granted, free of charge, to any person obtaining a copy
	* of this software and associated documentation files (the "Software"), to deal
	* in the Software without restriction, including without limitation the rights
	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	* copies of the Software, and to permit persons to whom the Software is
	* furnished to do so, subject to the following conditions:
	*
	* The above copyright notice and this permission notice shall be included in
	* all copies or substantial portions of the Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	* THE SOFTWARE.
	*/

	#include "tech/TechModel.h"

	#include <cmath>

	#include "model/std_cells/StdCellLib.h"

	namespace DSENT
	{
	TechModel::TechModel()
	: m_std_cell_lib_(NULL), m_available_wire_layers_(NULL)
	{}

	TechModel::~TechModel()
	{}

	const String& TechModel::get(const String &key_) const
	{
	return params.at(key_);
	}

	void TechModel::setStdCellLib(const StdCellLib* std_cell_lib_)
	{
	m_std_cell_lib_ = std_cell_lib_;
	return;
	}

	const StdCellLib* TechModel::getStdCellLib() const
	{
	return m_std_cell_lib_;
	}

	TechModel* TechModel::clone() const
	{
	return new TechModel(*this);
	}

	void TechModel::readFile(const String& filename_)
	{
	// Read the main technology file
	LibUtil::readFile(filename_, params);

	// Search for "INCLUDE" to include more technology files
	for (const auto &it : params)
	{
	const String& key = it.first;
	if(key.compare(0, 8, "INCLUDE_") == 0)
	{
	const String& include_filename = it.second;
	LibUtil::readFile(include_filename, params);
	}
	}

	// Set the available wire layers
	const vector<String>& available_wire_layer_vector = get("Wire->AvailableLayers").split("[,]");
	m_available_wire_layers_ = new std::set<String>;
	for(unsigned int i = 0; i < available_wire_layer_vector.size(); ++i)
	{
	m_available_wire_layers_->insert(available_wire_layer_vector[i]);
	}
	}

	//-------------------------------------------------------------------------
	// Transistor Related Functions
	//-------------------------------------------------------------------------
	//Returns the leakage current of NMOS transistors, given the transistor stakcing, transistor widths, and input combination
	double TechModel::calculateNmosLeakageCurrent(unsigned int num_stacks_, double uni_stacked_mos_width_, unsigned int input_vector_) const
	{
	vector<double> stacked_mos_widths_(num_stacks_, uni_stacked_mos_width_);
	return calculateNmosLeakageCurrent(num_stacks_, stacked_mos_widths_, input_vector_);
	}

	//Returns the leakage current of NMOS transistors, given the transistor stakcing, transistor widths, and input combination
	double TechModel::calculateNmosLeakageCurrent(unsigned int num_stacks_, const vector<double>& stacked_mos_widths_, unsigned int input_vector_) const
	{
	// Get technology parameters
	double vdd = get("Vdd");
	double temp = get("Temperature");
	double char_temp = get("Nmos->CharacterizedTemperature");
	double min_off_current = get("Nmos->MinOffCurrent");
	double off_current = get("Nmos->OffCurrent");
	double subthreshold_swing = get("Nmos->SubthresholdSwing");
	double dibl = get("Nmos->DIBL");
	double temp_swing = get("Nmos->SubthresholdTempSwing");

	// Map dibl to a swing value for easier calculation
	double dibl_swing = subthreshold_swing / dibl;

	//Calculate the leakage current factor
	double leakage_current_factor = calculateLeakageCurrentFactor(num_stacks_, stacked_mos_widths_, input_vector_, vdd, subthreshold_swing, dibl_swing);

	// Calcualte actual leakage current at characterized temperature
	double leakage_current_char_tmp = stacked_mos_widths_[0] * off_current * std::pow(10.0, leakage_current_factor);
	leakage_current_char_tmp = std::max(min_off_current, leakage_current_char_tmp);

	// Calculate actual leakage current at temp
	double leakage_current = leakage_current_char_tmp * std::pow(10.0, (temp - char_temp) / temp_swing);

	return leakage_current;
	}

	double TechModel::calculatePmosLeakageCurrent(unsigned int num_stacks_, double uni_stacked_mos_width_, unsigned int input_vector_) const
	{
	vector<double> stacked_mos_widths_(num_stacks_, uni_stacked_mos_width_);
	return calculatePmosLeakageCurrent(num_stacks_, stacked_mos_widths_, input_vector_);
	}

	//Returns the leakage current of PMOS transistors, given the transistor stakcing, transistor widths, and input combination
	double TechModel::calculatePmosLeakageCurrent(unsigned int num_stacks_, const vector<double>& stacked_mos_widths_, unsigned int input_vector_) const
	{
	// Get technology parameters
	double vdd = get("Vdd");
	double temp = get("Temperature");
	double char_temp = get("Pmos->CharacterizedTemperature");
	double min_off_current = get("Pmos->MinOffCurrent");
	double off_current = get("Pmos->OffCurrent");
	double dibl = get("Pmos->DIBL");
	double subthreshold_swing = get("Pmos->SubthresholdSwing");
	double temp_swing = get("Nmos->SubthresholdTempSwing");

	// Map dibl to a swing value for easier calculation
	double dibl_swing = subthreshold_swing / dibl;

	//Calculate the leakage current factor
	double leakage_current_factor = calculateLeakageCurrentFactor(num_stacks_, stacked_mos_widths_, input_vector_, vdd, subthreshold_swing, dibl_swing);

	// Calcualte actual leakage current at characterized temperature
	double leakage_current_char_tmp = stacked_mos_widths_[0] * off_current * std::pow(10.0, leakage_current_factor);
	leakage_current_char_tmp = std::max(min_off_current, leakage_current_char_tmp);

	// Calculate actual leakage current at temp
	double leakage_current = leakage_current_char_tmp * std::pow(10.0, (temp - char_temp) / temp_swing);

	return leakage_current;
	}

	//Returns the leakage current, given the transistor stakcing, transistor widths, input combination,
	//and technology information (vdd, subthreshold swing, subthreshold dibl swing)
	double TechModel::calculateLeakageCurrentFactor(unsigned int num_stacks_, const vector<double>& stacked_mos_widths_, unsigned int input_vector_, double vdd_, double subthreshold_swing_, double dibl_swing_) const
	{
	// check everything is valid
	ASSERT(num_stacks_ >= 1, "[Error] Number of stacks must be >= 1!");
	ASSERT(stacked_mos_widths_.size() == num_stacks_, "[Error] Mismatch in number of stacks and the widths specified!");

	//Use short name in this method
	const double s1 = subthreshold_swing_;
	const double s2 = dibl_swing_;

	// Decode input combinations from input_vector_
	std::vector<double> vs(num_stacks_, 0.0);
	for(int i = 0; i < (int)num_stacks_; ++i)
	{
	double current_input = (double(input_vector_ & 0x1))*vdd_;
	vs[i] = (current_input);
	input_vector_ >>= 1;
	}
	// If the widths pointer is NULL, width is set to 1 by default
	vector<double> ws = stacked_mos_widths_;

	//Solve voltages at internal nodes of stacked transistors
	// v[0] = 0
	// v[num_stacks_] = vdd_
	// v[i] = (1.0/(2s1 + s2))((s1 + s2)v[i - 1] + s1v[i + 1]
	// + s2(vs[i + 1] - vs[i]) + s1s2*log10(ws[i + 1]/ws[i]))
	//Use tri-matrix solver to solve the above linear system

	double A = -(s1 + s2);
	double B = 2*s1 + s2;
	double C = -s1;
	std::vector<double> a(num_stacks_ - 1, 0);
	std::vector<double> b(num_stacks_ - 1, 0);
	std::vector<double> c(num_stacks_ - 1, 0);
	std::vector<double> d(num_stacks_ - 1, 0);
	std::vector<double> v(num_stacks_ + 1, 0);
	unsigned int eff_num_stacks = num_stacks_;
	bool is_found_valid_v = false;
	do
	{
	//Set boundary condition
	v[0] = 0;
	v[eff_num_stacks] = vdd_;

	//If the effective number of stacks is 1, no matrix needs to be solved
	if(eff_num_stacks == 1)
	{
	break;
	}

	//----------------------------------------------------------------------
	//Setup the tri-matrix
	//----------------------------------------------------------------------
	for(int i = 0; i < (int)eff_num_stacks-2; ++i)
	{
	a[i + 1] = A;
	c[i] = C;
	}
	for(int i = 0; i < (int)eff_num_stacks-1; ++i)
	{
	b[i] = B;
	d[i] = s2(vs[i + 1] - vs[i]) + s1s2*std::log10(ws[i + 1]/ws[i]);
	if(i == ((int)eff_num_stacks - 2))
	{
	d[i] -= C*vdd_;
	}
	}
	//----------------------------------------------------------------------

	//----------------------------------------------------------------------
	//Solve the tri-matrix
	//----------------------------------------------------------------------
	for(int i = 1; i < (int)eff_num_stacks-1; ++i)
	{
	double m = a[i]/b[i - 1];
	b[i] -= m*c[i - 1];
	d[i] -= m*d[i - 1];
	}

	v[eff_num_stacks - 1] = d[eff_num_stacks - 2]/b[eff_num_stacks - 2];
	for(int i = eff_num_stacks - 3; i >= 0; --i)
	{
	v[i + 1] = (d[i] - c[i]*v[i + 2])/b[i];
	}
	//----------------------------------------------------------------------

	//Check if the internal voltages are in increasing order
	is_found_valid_v = true;
	for(int i = 1; i <= (int)eff_num_stacks; ++i)
	{
	//If the ith internal voltage is not in increasing order
	//(i-1)th transistor is in triode region
	//Remove the transistors in triode region as it does not exist
	if(v[i] < v[i - 1])
	{
	is_found_valid_v = false;
	eff_num_stacks--;
	vs.erase(vs.begin() + i - 1);
	ws.erase(ws.begin() + i - 1);
	break;
	}
	}
	} while(!is_found_valid_v);

	//Calculate the leakage current of the bottom transistor (first not in triode region)
	double vgs = vs[0] - v[0];
	double vds = v[1] - v[0];
	double leakage_current_factor = vgs/s1 + (vds - vdd_)/s2;
	//TODO - Check if the leakage current calculate for other transistors is identical

	return leakage_current_factor;
	}
	//-------------------------------------------------------------------------

	//-------------------------------------------------------------------------
	// Wire Related Functions
	//-------------------------------------------------------------------------
	bool TechModel::isWireLayerExist(const String& layer_name_) const
	{
	std::set<String>::const_iterator it;
	it = m_available_wire_layers_->find(layer_name_);
	return (it != m_available_wire_layers_->end());
	}

	const std::set<String>* TechModel::getAvailableWireLayers() const
	{
	return m_available_wire_layers_;
	}

	double TechModel::calculateWireCapacitance(const String& layer_name_, double width_, double spacing_, double length_) const
	{
	// Get technology parameter
	double min_width = get("Wire->" + layer_name_ + "->MinWidth").toDouble();
	double min_spacing = get("Wire->" + layer_name_ + "->MinSpacing").toDouble();
	double metal_thickness = get("Wire->" + layer_name_ + "->MetalThickness").toDouble();
	double dielec_thickness = get("Wire->" + layer_name_ + "->DielectricThickness").toDouble();
	double dielec_const = get("Wire->" + layer_name_ + "->DielectricConstant").toDouble();

	ASSERT(width_ >= min_width, "[Error] Wire width must be >= " + (String) min_width + "!");
	ASSERT(spacing_ >= min_spacing, "[Error] Wire spacing must be >= " + (String) min_spacing + "!");
	ASSERT(length_ >= 0, "[Error] Wire length must be >= 0!");

	double A, B, C;
	// Calculate ground capacitance
	A = width_ / dielec_thickness;
	B = 2.04std::pow((spacing_ / (spacing_ + 0.54 dielec_thickness)), 1.77);
	C = std::pow((metal_thickness / (metal_thickness + 4.53 * dielec_thickness)), 0.07);
	double unit_gnd_cap = dielec_const * 8.85e-12 * (A + B * C);

	A = 1.14 * (metal_thickness / spacing_) * std::exp(-4.0 * spacing_ / (spacing_ + 8.01 * dielec_thickness));
	B = 2.37 * std::pow((width_ / (width_ + 0.31 * spacing_)), 0.28);
	C = std::pow((dielec_thickness / (dielec_thickness + 8.96 * spacing_)), 0.76) *
	std::exp(-2.0 * spacing_ / (spacing_ + 6.0 * dielec_thickness));
	double unit_coupling_cap = dielec_const * 8.85e-12 * (A + B * C);

	double total_cap = 2 * (unit_gnd_cap + unit_coupling_cap) * length_;
	return total_cap;
	}

	double TechModel::calculateWireResistance(const String& layer_name_, double width_, double length_) const
	{
	// Get technology parameter
	double min_width = get("Wire->" + layer_name_ + "->MinWidth");
	//double barrier_thickness = get("Wire->" + layer_name_ + "->BarrierThickness");
	double resistivity = get("Wire->" + layer_name_ + "->Resistivity");
	double metal_thickness = get("Wire->" + layer_name_ + "->MetalThickness");

	ASSERT(width_ >= min_width, "[Error] Wire width must be >= " + (String) min_width + "!");
	ASSERT(length_ >= 0, "[Error] Wire length must be >= 0!");

	// Calculate Rho
	// double rho = 2.202e-8 + (1.030e-15 / (width_ - 2.0 * barrier_thickness));

	double unit_res = resistivity / (width_ * metal_thickness);
	//double unit_res = rho / ((width_ - 2.0 * barrier_thickness) * (metal_thickness - barrier_thickness));

	double total_res = unit_res * length_;
	return total_res;
	}
	//-------------------------------------------------------------------------

	TechModel::TechModel(const TechModel& tech_model_)
	: m_std_cell_lib_(tech_model_.m_std_cell_lib_),
	params(tech_model_.params)
	{}
	} // namespace DSENT