luke
/
OpenSTA
mirror of https://github.com/The-OpenROAD-Project/OpenSTA.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

TableAxis shared_ptr 

Signed-off-by: James Cherry <cherry@parallaxsw.com>
This commit is contained in:
James Cherry 2022-06-25 16:31:18 -07:00
parent dc9d20f8d5
commit a8a9b27077
13 changed files with 133 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/sta/InternalPower.hh
View File

@ -93,11 +93,11 @@ protected:
float &axis_value1,
float &axis_value2,
float &axis_value3) const;
float axisValue(TableAxis *axis,
float axisValue(TableAxisPtr axis,
float in_slew,
float load_cap) const;
bool checkAxes(const TableModel *model);
bool checkAxis(TableAxis *axis);
bool checkAxis(TableAxisPtr axis);
TableModel *model_;
};

24
include/sta/Liberty.hh
View File

@ -932,24 +932,24 @@ class TableTemplate
public:
explicit TableTemplate(const char *name);
TableTemplate(const char *name,
TableAxis *axis1,
TableAxis *axis2,
TableAxis *axis3);
TableAxisPtr axis1,
TableAxisPtr axis2,
TableAxisPtr axis3);
~TableTemplate();
const char *name() const { return name_; }
void setName(const char *name);
TableAxis *axis1() const { return axis1_; }
void setAxis1(TableAxis *axis);
TableAxis *axis2() const { return axis2_; }
void setAxis2(TableAxis *axis);
TableAxis *axis3() const { return axis3_; }
void setAxis3(TableAxis *axis);
TableAxisPtr axis1() const { return axis1_; }
void setAxis1(TableAxisPtr axis);
TableAxisPtr axis2() const { return axis2_; }
void setAxis2(TableAxisPtr axis);
TableAxisPtr axis3() const { return axis3_; }
void setAxis3(TableAxisPtr axis);
protected:
const char *name_;
TableAxis *axis1_;
TableAxis *axis2_;
TableAxis *axis3_;
TableAxisPtr axis1_;
TableAxisPtr axis2_;
TableAxisPtr axis3_;
};
class TestCell

1
include/sta/LibertyClass.hh
View File

@ -69,6 +69,7 @@ typedef Set<LibertyCell*> LibertyCellSet;
typedef Vector<float> FloatSeq;
typedef Vector<FloatSeq*> FloatTable;
typedef std::shared_ptr<TimingArcAttrs> TimingArcAttrsPtr;
typedef std::shared_ptr<TableAxis> TableAxisPtr;
enum class ScaleFactorType : unsigned {
pin_cap,

62
include/sta/TableModel.hh
View File

@ -17,6 +17,8 @@
#pragma once
#include <string>
#include <memory>
#include "MinMax.hh"
#include "Vector.hh"
#include "Transition.hh"
@ -81,7 +83,7 @@ protected:
float &slew,
float &cap) const;
virtual void setIsScaled(bool is_scaled);
float axisValue(TableAxis *axis,
float axisValue(TableAxisPtr axis,
float load_cap,
float in_slew,
float related_out_cap) const;
@ -110,7 +112,7 @@ protected:
float &axis_value1,
float &axis_value2,
float &axis_value3) const;
static bool checkAxis(TableAxis *axis);
static bool checkAxis(TableAxisPtr axis);
TableModel *delay_model_;
TableModel *delay_sigma_models_[EarlyLate::index_count];
@ -163,7 +165,7 @@ protected:
float &axis_value1,
float &axis_value2,
float &axis_value3) const;
float axisValue(TableAxis *axis,
float axisValue(TableAxisPtr axis,
float load_cap,
float in_slew,
float related_out_cap) const;
@ -178,7 +180,7 @@ protected:
float related_out_cap,
int digits,
string *result) const;
static bool checkAxis(TableAxis *axis);
static bool checkAxis(TableAxisPtr axis);
TableModel *model_;
TableModel *sigma_models_[EarlyLate::index_count];
@ -196,9 +198,9 @@ public:
void setScaleFactorType(ScaleFactorType type);
int order() const;
TableTemplate *tblTemplate() const { return tbl_template_; }
TableAxis *axis1() const;
TableAxis *axis2() const;
TableAxis *axis3() const;
TableAxisPtr axis1() const;
TableAxisPtr axis2() const;
TableAxisPtr axis3() const;
void setIsScaled(bool is_scaled);
float value(size_t index1,
size_t index2,
@ -253,9 +255,9 @@ public:
virtual ~Table() {}
void setScaleFactorType(ScaleFactorType type);
virtual int order() const = 0;
virtual TableAxis *axis1() const { return nullptr; }
virtual TableAxis *axis2() const { return nullptr; }
virtual TableAxis *axis3() const { return nullptr; }
virtual TableAxisPtr axis1() const { return nullptr; }
virtual TableAxisPtr axis2() const { return nullptr; }
virtual TableAxisPtr axis3() const { return nullptr; }
void setIsScaled(bool is_scaled);
virtual float value(size_t axis_idx1,
size_t axis_idx2,
@ -320,11 +322,10 @@ class Table1 : public Table
{
public:
Table1(FloatSeq *values,
TableAxis *axis1,
bool own_axis1);
TableAxisPtr axis1);
virtual ~Table1();
virtual int order() const { return 1; }
virtual TableAxis *axis1() const { return axis1_; }
virtual TableAxisPtr axis1() const { return axis1_; }
virtual float value(size_t index1,
size_t index2,
size_t index3) const;
@ -348,8 +349,7 @@ public:
private:
FloatSeq *values_;
TableAxis *axis1_;
bool own_axis1_;
TableAxisPtr axis1_;
};
// Two dimensional table.
@ -357,14 +357,12 @@ class Table2 : public Table
{
public:
Table2(FloatTable *values,
TableAxis *axis1,
bool own_axis1,
TableAxis *axis2,
bool own_axis2);
TableAxisPtr axis1,
TableAxisPtr axis2);
virtual ~Table2();
virtual int order() const { return 2; }
TableAxis *axis1() const { return axis1_; }
TableAxis *axis2() const { return axis2_; }
TableAxisPtr axis1() const { return axis1_; }
TableAxisPtr axis2() const { return axis2_; }
virtual float value(size_t index1,
size_t index2,
size_t index3) const;
@ -390,11 +388,9 @@ public:
protected:
FloatTable *values_;
// Row.
TableAxis *axis1_;
bool own_axis1_;
TableAxisPtr axis1_;
// Column.
TableAxis *axis2_;
bool own_axis2_;
TableAxisPtr axis2_;
};
// Three dimensional table.
@ -402,15 +398,12 @@ class Table3 : public Table2
{
public:
Table3(FloatTable *values,
TableAxis *axis1,
bool own_axis1,
TableAxis *axis2,
bool own_axis2,
TableAxis *axis3,
bool own_axis3);
virtual ~Table3();
TableAxisPtr axis1,
TableAxisPtr axis2,
TableAxisPtr axis3);
virtual ~Table3() {}
virtual int order() const { return 3; }
TableAxis *axis3() const { return axis3_; }
TableAxisPtr axis3() const { return axis3_; }
virtual float value(size_t index1,
size_t index2,
size_t index3) const;
@ -432,8 +425,7 @@ public:
using Table::findValue;
private:
TableAxis *axis3_;
bool own_axis3_;
TableAxisPtr axis3_;
};
class TableAxis

10
liberty/InternalPower.cc
View File

@ -194,7 +194,7 @@ InternalPowerModel::findAxisValues(float in_slew,
}
float
InternalPowerModel::axisValue(TableAxis *axis,
InternalPowerModel::axisValue(TableAxisPtr axis,
float in_slew,
float load_cap) const
{
@ -212,9 +212,9 @@ InternalPowerModel::axisValue(TableAxis *axis,
bool
InternalPowerModel::checkAxes(const TableModel *model)
{
TableAxis *axis1 = model->axis1();
TableAxis *axis2 = model->axis2();
TableAxis *axis3 = model->axis3();
TableAxisPtr axis1 = model->axis1();
TableAxisPtr axis2 = model->axis2();
TableAxisPtr axis3 = model->axis3();
bool axis_ok = true;
if (axis1)
axis_ok &= checkAxis(model->axis1());
@ -225,7 +225,7 @@ InternalPowerModel::checkAxes(const TableModel *model)
}
bool
InternalPowerModel::checkAxis(TableAxis *axis)
InternalPowerModel::checkAxis(TableAxisPtr axis)
{
TableAxisVariable var = axis->variable();
return var == TableAxisVariable::constrained_pin_transition

27
liberty/Liberty.cc
View File

@ -337,7 +337,7 @@ LibertyLibrary::degradeWireSlew(const LibertyCell *cell,
case 0:
return model->findValue(this, cell, pvt, 0.0, 0.0, 0.0);
case 1: {
TableAxis *axis1 = model->axis1();
TableAxisPtr axis1 = model->axis1();
TableAxisVariable var1 = axis1->variable();
if (var1 == TableAxisVariable::output_pin_transition)
return model->findValue(this, cell, pvt, in_slew, 0.0, 0.0);
@ -349,8 +349,8 @@ LibertyLibrary::degradeWireSlew(const LibertyCell *cell,
}
}
case 2: {
TableAxis *axis1 = model->axis1();
TableAxis *axis2 = model->axis2();
TableAxisPtr axis1 = model->axis1();
TableAxisPtr axis2 = model->axis2();
TableAxisVariable var1 = axis1->variable();
TableAxisVariable var2 = axis2->variable();
if (var1 == TableAxisVariable::output_pin_transition
@ -379,14 +379,14 @@ LibertyLibrary::checkSlewDegradationAxes(Table *table)
case 0:
return true;
case 1: {
TableAxis *axis1 = table->axis1();
TableAxisPtr axis1 = table->axis1();
TableAxisVariable var1 = axis1->variable();
return var1 == TableAxisVariable::output_pin_transition
|| var1 == TableAxisVariable::connect_delay;
}
case 2: {
TableAxis *axis1 = table->axis1();
TableAxis *axis2 = table->axis2();
TableAxisPtr axis1 = table->axis1();
TableAxisPtr axis2 = table->axis2();
TableAxisVariable var1 = axis1->variable();
TableAxisVariable var2 = axis2->variable();
return (var1 == TableAxisVariable::output_pin_transition
@ -2510,9 +2510,9 @@ TableTemplate::TableTemplate(const char *name) :
}
TableTemplate::TableTemplate(const char *name,
TableAxis *axis1,
TableAxis *axis2,
TableAxis *axis3) :
TableAxisPtr axis1,
TableAxisPtr axis2,
TableAxisPtr axis3) :
name_(stringCopy(name)),
axis1_(axis1),
axis2_(axis2),
@ -2523,9 +2523,6 @@ TableTemplate::TableTemplate(const char *name,
TableTemplate::~TableTemplate()
{
stringDelete(name_);
delete axis1_;
delete axis2_;
delete axis3_;
}
void
@ -2536,19 +2533,19 @@ TableTemplate::setName(const char *name)
}
void
TableTemplate::setAxis1(TableAxis *axis)
TableTemplate::setAxis1(TableAxisPtr axis)
{
axis1_ = axis;
}
void
TableTemplate::setAxis2(TableAxis *axis)
TableTemplate::setAxis2(TableAxisPtr axis)
{
axis2_ = axis;
}
void
TableTemplate::setAxis3(TableAxis *axis)
TableTemplate::setAxis3(TableAxisPtr axis)
{
axis3_ = axis;
}

43
liberty/LibertyReader.cc
View File

@ -1298,33 +1298,30 @@ void
LibertyReader::endTableTemplate(LibertyGroup *group)
{
if (tbl_template_) {
TableAxis *axis;
makeAxis(0, group, axis);
if (axis)
tbl_template_->setAxis1(axis);
makeAxis(1, group, axis);
if (axis)
tbl_template_->setAxis2(axis);
makeAxis(2, group, axis);
if (axis)
tbl_template_->setAxis3(axis);
TableAxisPtr axis1 = makeAxis(0, group);
if (axis1)
tbl_template_->setAxis1(axis1);
TableAxisPtr axis2 = makeAxis(1, group);
if (axis2)
tbl_template_->setAxis2(axis2);
TableAxisPtr axis3 = makeAxis(2, group);
if (axis3)
tbl_template_->setAxis3(axis3);
tbl_template_ = nullptr;
}
}
void
TableAxisPtr
LibertyReader::makeAxis(int index,
LibertyGroup *group,
TableAxis *&axis)
LibertyGroup *group)
{
axis = nullptr;
TableAxisVariable axis_var = axis_var_[index];
FloatSeq *axis_values = axis_values_[index];
if (axis_var != TableAxisVariable::unknown && axis_values) {
const Units *units = library_->units();
float scale = tableVariableUnit(axis_var, units)->scale();
scaleFloats(axis_values, scale);
axis = new TableAxis(axis_var, axis_values);
return std::make_shared<TableAxis>(axis_var, axis_values);
}
else if (axis_var == TableAxisVariable::unknown && axis_values) {
libWarn(62, group, "missing variable_%d attribute.", index + 1);
@ -1333,6 +1330,7 @@ LibertyReader::makeAxis(int index,
}
// No warning for missing index_xx attributes because they are
// not required by ic_shell.
return nullptr;
}
static void
@ -3878,7 +3876,6 @@ LibertyReader::beginTable(LibertyGroup *group,
axis_[0] = axis_[1] = axis_[2] = nullptr;
}
clearAxisValues();
own_axis_[0] = own_axis_[1] = own_axis_[2] = false;
table_ = nullptr;
table_model_scale_ = scale;
}
@ -3926,25 +3923,20 @@ LibertyReader::makeTable(LibertyAttr *attr,
FloatTable *table = makeFloatTable(attr,
axis_[0]->size()*axis_[1]->size(),
axis_[2]->size(), scale);
table_ = new Table3(table,
axis_[0], own_axis_[0],
axis_[1], own_axis_[1],
axis_[2], own_axis_[2]);
table_ = new Table3(table, axis_[0], axis_[1], axis_[2]);
}
else if (axis_[0] && axis_[1]) {
// Row variable1/axis[0]
// Column variable2/axis[1]
FloatTable *table = makeFloatTable(attr, axis_[0]->size(),
axis_[1]->size(), scale);
table_ = new Table2(table,
axis_[0], own_axis_[0],
axis_[1], own_axis_[1]);
table_ = new Table2(table, axis_[0], axis_[1]);
}
else if (axis_[0]) {
FloatTable *table = makeFloatTable(attr, 1, axis_[0]->size(), scale);
FloatSeq *values = (*table)[0];
delete table;
table_ = new Table1(values, axis_[0], own_axis_[0]);
table_ = new Table1(values, axis_[0]);
}
else {
FloatTable *table = makeFloatTable(attr, 1, 1, scale);
@ -4017,8 +4009,7 @@ LibertyReader::makeTableAxis(int index)
const Units *units = library_->units();
float scale = tableVariableUnit(var, units)->scale();
scaleFloats(values, scale);
axis_[index] = new TableAxis(var, values);
own_axis_[index] = true;
axis_[index] = std::make_shared<TableAxis>(var, values);
}
}

8
liberty/LibertyReaderPvt.hh
View File

@ -481,9 +481,8 @@ protected:
LibertyAttr *attr);
void visitIndex(int index,
LibertyAttr *attr);
void makeAxis(int index,
LibertyGroup *group,
TableAxis *&axis);
TableAxisPtr makeAxis(int index,
LibertyGroup *group);
FloatSeq *readFloatSeq(LibertyAttr *attr,
float scale);
void variableValue(const char *var,
@ -564,8 +563,7 @@ protected:
PathType path_type_;
LibertyPgPort *pg_port_;
ScaleFactorType scale_factor_type_;
TableAxis *axis_[3];
bool own_axis_[3];
TableAxisPtr axis_[3];
Table *table_;
float table_model_scale_;
ModeDef *mode_def_;

10
liberty/LibertyWriter.cc
View File

@ -60,7 +60,7 @@ protected:
void writeTableModel0(const TableModel *model);
void writeTableModel1(const TableModel *model);
void writeTableModel2(const TableModel *model);
void writeTableAxis(TableAxis *axis,
void writeTableAxis(TableAxisPtr axis,
int index);
const char *asString(bool value);
@ -204,9 +204,9 @@ LibertyWriter::writeTableTemplates()
void
LibertyWriter::writeTableTemplate(TableTemplate *tbl_template)
{
TableAxis *axis1 = tbl_template->axis1();
TableAxis *axis2 = tbl_template->axis2();
TableAxis *axis3 = tbl_template->axis3();
TableAxisPtr axis1 = tbl_template->axis1();
TableAxisPtr axis2 = tbl_template->axis2();
TableAxisPtr axis3 = tbl_template->axis3();
// skip scalar templates
if (axis1) {
fprintf(stream_, " lu_table_template(%s) {\n", tbl_template->name());
@ -229,7 +229,7 @@ LibertyWriter::writeTableTemplate(TableTemplate *tbl_template)
}
void
LibertyWriter::writeTableAxis(TableAxis *axis,
LibertyWriter::writeTableAxis(TableAxisPtr axis,
int index)
{
fprintf(stream_, " index_%d (\"", index);

74
liberty/TableModel.cc
View File

@ -268,9 +268,9 @@ GateTableModel::maxCapSlew(const LibertyCell *cell,
float &cap) const
{
const LibertyLibrary *library = cell->libertyLibrary();
TableAxis *axis1 = slew_model_->axis1();
TableAxis *axis2 = slew_model_->axis2();
TableAxis *axis3 = slew_model_->axis3();
TableAxisPtr axis1 = slew_model_->axis1();
TableAxisPtr axis2 = slew_model_->axis2();
TableAxisPtr axis3 = slew_model_->axis3();
if (axis1
&& axis1->variable() == TableAxisVariable::total_output_net_capacitance) {
cap = axis1->axisValue(axis1->size() - 1);
@ -300,7 +300,7 @@ GateTableModel::maxCapSlew(const LibertyCell *cell,
}
float
GateTableModel::axisValue(TableAxis *axis,
GateTableModel::axisValue(TableAxisPtr axis,
float in_slew,
float load_cap,
float related_out_cap) const
@ -322,9 +322,9 @@ GateTableModel::axisValue(TableAxis *axis,
bool
GateTableModel::checkAxes(const Table *table)
{
TableAxis *axis1 = table->axis1();
TableAxis *axis2 = table->axis2();
TableAxis *axis3 = table->axis3();
TableAxisPtr axis1 = table->axis1();
TableAxisPtr axis2 = table->axis2();
TableAxisPtr axis3 = table->axis3();
bool axis_ok = true;
if (axis1)
axis_ok &= checkAxis(table->axis1());
@ -336,7 +336,7 @@ GateTableModel::checkAxes(const Table *table)
}
bool
GateTableModel::checkAxis(TableAxis *axis)
GateTableModel::checkAxis(TableAxisPtr axis)
{
TableAxisVariable var = axis->variable();
return var == TableAxisVariable::total_output_net_capacitance
@ -510,7 +510,7 @@ CheckTableModel::findAxisValues(float from_slew,
}
float
CheckTableModel::axisValue(TableAxis *axis,
CheckTableModel::axisValue(TableAxisPtr axis,
float from_slew,
float to_slew,
float related_out_cap) const
@ -531,9 +531,9 @@ CheckTableModel::axisValue(TableAxis *axis,
bool
CheckTableModel::checkAxes(const Table *table)
{
TableAxis *axis1 = table->axis1();
TableAxis *axis2 = table->axis2();
TableAxis *axis3 = table->axis3();
TableAxisPtr axis1 = table->axis1();
TableAxisPtr axis2 = table->axis2();
TableAxisPtr axis3 = table->axis3();
bool axis_ok = true;
if (axis1)
axis_ok &= checkAxis(table->axis1());
@ -545,7 +545,7 @@ CheckTableModel::checkAxes(const Table *table)
}
bool
CheckTableModel::checkAxis(TableAxis *axis)
CheckTableModel::checkAxis(TableAxisPtr axis)
{
TableAxisVariable var = axis->variable();
return var == TableAxisVariable::constrained_pin_transition
@ -590,19 +590,19 @@ TableModel::setIsScaled(bool is_scaled)
is_scaled_ = is_scaled;
}
TableAxis *
TableAxisPtr
TableModel::axis1() const
{
return table_->axis1();
}
TableAxis *
TableAxisPtr
TableModel::axis2() const
{
return table_->axis2();
}
TableAxis *
TableAxisPtr
TableModel::axis3() const
{
return table_->axis3();
@ -762,20 +762,16 @@ Table0::report(const Units *units,
////////////////////////////////////////////////////////////////
Table1::Table1(FloatSeq *values,
TableAxis *axis1,
bool own_axis1) :
TableAxisPtr axis1) :
Table(),
values_(values),
axis1_(axis1),
own_axis1_(own_axis1)
axis1_(axis1)
{
}
Table1::~Table1()
{
delete values_;
if (own_axis1_)
delete axis1_;
}
float
@ -887,16 +883,12 @@ Table1::report(const Units *units,
////////////////////////////////////////////////////////////////
Table2::Table2(FloatTable *values,
TableAxis *axis1,
bool own_axis1,
TableAxis *axis2,
bool own_axis2) :
TableAxisPtr axis1,
TableAxisPtr axis2) :
Table(),
values_(values),
axis1_(axis1),
own_axis1_(own_axis1),
axis2_(axis2),
own_axis2_(own_axis2)
axis2_(axis2)
{
}
@ -904,10 +896,6 @@ Table2::~Table2()
{
values_->deleteContents();
delete values_;
if (own_axis1_)
delete axis1_;
if (own_axis2_)
delete axis2_;
}
float
@ -1089,24 +1077,14 @@ Table2::report(const Units *units,
////////////////////////////////////////////////////////////////
Table3::Table3(FloatTable *values,
TableAxis *axis1,
bool own_axis1,
TableAxis *axis2,
bool own_axis2,
TableAxis *axis3,
bool own_axis3) :
Table2(values, axis1, own_axis1, axis2, own_axis2),
axis3_(axis3),
own_axis3_(own_axis3)
TableAxisPtr axis1,
TableAxisPtr axis2,
TableAxisPtr axis3) :
Table2(values, axis1, axis2),
axis3_(axis3)
{
}
Table3::~Table3()
{
if (own_axis3_)
delete axis3_;
}
float
Table3::value(size_t index1,
size_t index2,

14
search/MakeTimingModel.cc
View File

@ -519,7 +519,7 @@ MakeTimingModel::makeGateModelTable(const Pin *output_pin,
drvr_self_delay, drvr_self_slew);
const TableModel *drvr_table = drvr_gate_model->delayModel();
const TableAxis *drvr_load_axis = loadCapacitanceAxis(drvr_table);
const TableAxisPtr drvr_load_axis = loadCapacitanceAxis(drvr_table);
const FloatSeq *drvr_axis_values = drvr_load_axis->values();
FloatSeq *load_values = new FloatSeq;
@ -538,12 +538,12 @@ MakeTimingModel::makeGateModelTable(const Pin *output_pin,
}
FloatSeq *axis_values = new FloatSeq(*drvr_axis_values);
TableAxis *load_axis =
new TableAxis(TableAxisVariable::total_output_net_capacitance,
axis_values);
TableAxisPtr load_axis =
std::make_shared<TableAxis>(TableAxisVariable::total_output_net_capacitance,
axis_values);
Table *delay_table = new Table1(load_values, load_axis, true);
Table *slew_table = new Table1(slew_values, load_axis, true);
Table *delay_table = new Table1(load_values, load_axis);
Table *slew_table = new Table1(slew_values, load_axis);
string template_name = "template_";
template_name += std::to_string(tbl_template_index_++);
@ -570,7 +570,7 @@ MakeTimingModel::makeGateModelTable(const Pin *output_pin,
return makeGateModelScalar(delay, slew, rf);
}
TableAxis *
TableAxisPtr
MakeTimingModel::loadCapacitanceAxis(const TableModel *table)
{
if (table->axis1()->variable() == TableAxisVariable::total_output_net_capacitance)

2
search/MakeTimingModel.hh
View File

@ -75,7 +75,7 @@ private:
TimingModel *makeGateModelTable(const Pin *output_pin,
Delay delay,
RiseFall *rf);
TableAxis *loadCapacitanceAxis(const TableModel *table);
TableAxisPtr loadCapacitanceAxis(const TableModel *table);
LibertyPort *modelPort(const Pin *pin);
Sta *sta_;

32
search/WritePathSpice.cc
View File

@ -575,25 +575,23 @@ WritePathSpice::slewAxisMinValue(TimingArc *arc)
GateTableModel *gate_model = dynamic_cast<GateTableModel*>(arc->model());
if (gate_model) {
const TableModel *model = gate_model->delayModel();
TableAxis *axis;
TableAxisVariable var;
axis = model->axis1();
var = axis->variable();
if (var == TableAxisVariable::input_transition_time
|| var == TableAxisVariable::input_net_transition)
return axis->axisValue(0);
TableAxisPtr axis1 = model->axis1();
TableAxisVariable var1 = axis1->variable();
if (var1 == TableAxisVariable::input_transition_time
|| var1 == TableAxisVariable::input_net_transition)
return axis1->axisValue(0);
axis = model->axis2();
var = axis->variable();
if (var == TableAxisVariable::input_transition_time
|| var == TableAxisVariable::input_net_transition)
return axis->axisValue(0);
TableAxisPtr axis2 = model->axis2();
TableAxisVariable var2 = axis2->variable();
if (var2 == TableAxisVariable::input_transition_time
|| var2 == TableAxisVariable::input_net_transition)
return axis2->axisValue(0);
axis = model->axis3();
var = axis->variable();
if (var == TableAxisVariable::input_transition_time
|| var == TableAxisVariable::input_net_transition)
return axis->axisValue(0);
TableAxisPtr axis3 = model->axis3();
TableAxisVariable var3 = axis3->variable();
if (var3 == TableAxisVariable::input_transition_time
|| var3 == TableAxisVariable::input_net_transition)
return axis3->axisValue(0);
}
return 0.0;
}