oalefinlayer.cpp

openaccess读def,lef文件所用的源代码

// 
// This function handles the resistance attributes for the specified layer.
// *****************************************************************************
void
LefInLayer::parseCutRes()
{
    if (lefLayer->hasResistancePerCut()) {
	lefIn.setProp(layer, cLefLayerRes,
		      oaFloat(lefLayer->resistancePerCut()));
    }
}



// *****************************************************************************
// LefInLayer::parseRes()
// 
// This function handles the resistance attributes for the specified layer.
// 
// Syntax:
//     [RESISTANCE RPERSQ value ;]
//
// The RESISTANCE is stored in OA using an oaIntProp on the layer, with the
// name "RESISTANCE".
// *****************************************************************************
void
LefInLayer::parseRes()
{
    if (lefLayer->hasResistance()) {
	lefIn.setProp(layer, cLefLayerRes, oaFloat(lefLayer->resistance()));
    }
}



// *****************************************************************************
// LefInLayer::parseCap()
// 
// This function handles the capacitance attributes for the specified layer.
// *****************************************************************************
void
LefInLayer::parseCap()
{
    if (lefLayer->hasCapacitance()) {
	lefIn.setProp(layer, cLefLayerCap, oaFloat(lefLayer->capacitance()));
    }
}



// *****************************************************************************
// LefInLayer::parseHeight()
// 
// This function handles the height attributes for the specified layer.
// *****************************************************************************
void
LefInLayer::parseHeight()
{
    if (lefLayer->hasHeight()) {
	lefIn.setProp(layer, cLefLayerHeight,
		      lefIn.uuToDBU(lefLayer->height()));
    }
}



// *****************************************************************************
// LefInLayer::parseThickness()
// 
// This function handles the Thickness attributes for the specified layer.
// *****************************************************************************
void 
LefInLayer::parseThickness()
{
    if (lefLayer->hasThickness()) {
	lefIn.setProp(layer, cLefLayerThickness,
		      lefIn.uuToDBU(lefLayer->thickness()));
    }
}



// *****************************************************************************
// LefInLayer::parseShrinkage()
// 
// This function handles the Shrinkage attributes for the specified layer.
// *****************************************************************************
void
LefInLayer::parseShrinkage()
{
    if (lefLayer->hasShrinkage()) {
	lefIn.setProp(layer, cLefLayerShrinkage,
		      lefIn.uuToDBU(lefLayer->shrinkage()));
    }
}



// *****************************************************************************
// LefInLayer::parseCapMul()
// 
// This function handles the cap multiplier attributes for the specified layer.
// *****************************************************************************
void
LefInLayer::parseCapMul()
{
    if (lefLayer->hasCapMultiplier()) {
	lefIn.setProp(layer, cLefLayerCapMul,
		      oaInt4(lefLayer->capMultiplier()));
    }
}



// *****************************************************************************
// LefInLayer::parseEdgeCap()
// 
// This function handles the EdgeCap attributes for the specified layer.
// *****************************************************************************
void
LefInLayer::parseEdgeCap()
{
    if (lefLayer->hasEdgeCap()) {
	lefIn.setProp(layer, cLefLayerEdgeCap, oaFloat(lefLayer->edgeCap()));
    }
}



// *****************************************************************************
// LefInLayer::parseDensity()
// 
// This function handles the density attributes for the specified layer.
// *****************************************************************************
void
LefInLayer::parseDensity()
{
    if (!lefLayer->hasMinimumDensity() && !lefLayer->hasMaximumDensity()) {
	return;
    }

    if (!lefLayer->hasDensityCheckWindow()) {
	throw LefDefError(cLayerNoDensityCheckWindow, lefLayer->name());
    }

    oaUInt4 windowSize = lefIn.uuToDBU(lefLayer->densityCheckWindowLength());
    oaUInt4 step = windowSize / 2;

    oaValue  *value;

    if (lefLayer->hasMinimumDensity()) {
	oa1DLookupTbl<oaInt4, oaFloat> table(1, "step", 0);

	table.setHeader(0, step);
	table.setValue(0, oaFloat(lefLayer->minimumDensity()));

	value = oaIntFltTblValue::create(lefIn.tech(), table);
	lefIn.setConstraint(lefIn.getFoundryRules(), oacMinDensity,
			    layer->getNumber(), value);
    }

    if (lefLayer->hasMaximumDensity()) {
	oa1DLookupTbl<oaInt4, oaFloat> table(1, "step", 0);

	table.setHeader(0, step);
	table.setValue(0, oaFloat(lefLayer->maximumDensity()));

	value = oaIntFltTblValue::create(lefIn.tech(), table);
	lefIn.setConstraint(lefIn.getFoundryRules(), oacMaxDensity,
			    layer->getNumber(), value);
    }
}



// *****************************************************************************
// LefInLayer::parseFill()
// 
// This function handles the FILL attributes for the specified layer.
// *****************************************************************************
void
LefInLayer::parseFill()
{
    if (lefLayer->hasFillActiveSpacing()) {
	oaValue *v = oaIntValue::create(lefIn.tech(),
					lefIn.uuToDBU(lefLayer->fillActiveSpacing()));
	
	lefIn.setConstraint(lefIn.getFoundryRules(), oacMinFillPatternSpacing, 
			    layer->getNumber(), v);
    }
}



// *****************************************************************************
// LefInLayer::parseAntenna()
// 
// This function handles the ANTENNA attributes for the specified layer.
// *****************************************************************************
void
LefInLayer::parseAntenna()
{
    if (lefLayer->hasAntennaLength()
	|| lefLayer->hasAntennaArea()) {
	return parseAntenna53();
    }
    
    if (lefLayer->numAntennaModel()) {
	return parseAntenna54();
    }
}

void
LefInLayer::parseAntenna53()
{
}

void
LefInLayer::parseAntenna54()
{
    oaAntennaRatioValue	*ratios[4];
    oaAntennaRatioValue	*cumRatios[4];

    for (oaUInt4 j = 0; j < 4; j++) {
	ratios[j] = NULL;
	cumRatios[j] = NULL;
    }

    for (oaInt4 j = 0; j < lefLayer->numAntennaModel(); j++) {
	lefiAntennaModel    *data = lefLayer->antennaModel(j);
	oaBoolean	    isSide = false;
	oaAntennaModelEnum  model = oacDefaultAntennaModel;
	oaString	    s = data->antennaOxide();

	if (s == "OXIDE2") {
	    model = oacSecondAntennaModel;
	} else if (s == "OXIDE3") {
	    model = oacThirdAntennaModel;
	} else if (s == "OXIDE4") {
	    model = oacFourthAntennaModel;
	}

	// FACTORS
	oaFloat factor = 1.;
	if (data->hasAntennaAreaFactor()
	    && !data->hasAntennaAreaFactorDUO()) {
	    factor = oaFloat(data->antennaAreaFactor());
	}
	
	oaFloat sideFactor = 1.;
	if (data->hasAntennaSideAreaFactor()
	    && !data->hasAntennaSideAreaFactorDUO()) {
	    sideFactor = oaFloat(data->antennaSideAreaFactor());
	}	


	// GATE values
	oaFloat	    gate = 0.;

	if (factor > 0 && data->hasAntennaAreaRatio()) {
	    gate = oaFloat(data->antennaAreaRatio()) / factor;

	} else if (sideFactor > 0 && data->hasAntennaSideAreaRatio()) {
	    gate = oaFloat(data->antennaSideAreaRatio()) / sideFactor;
	    isSide = true;
	}


	// GATE CUMULATIVE
	oaFloat	cumGate = 0.;

	if (factor > 0 && data->hasAntennaCumAreaRatio()) {
	    cumGate = oaFloat(data->antennaCumAreaRatio()) / factor;

	} else if (sideFactor > 0 && data->hasAntennaCumSideAreaRatio()) {
	    cumGate = oaFloat(data->antennaCumSideAreaRatio()) / sideFactor;
	    isSide = true;
	}
	

	// DIODE FACTORS
	if (data->hasAntennaAreaFactor()) {
	    factor = oaFloat(data->antennaAreaFactor());

	} else if (data->hasAntennaSideAreaFactor()) {
	    sideFactor = oaFloat(data->antennaSideAreaFactor());
	}


	// DIODE VALUES
	oa1DLookupTbl<oaInt8, oaFloat>	diode(0, "diode", 0);

	if (factor > 0 && data->hasAntennaDiffAreaRatio()) {
	    diode.setNumItems(1);
	    diode.setHeader(0, 0);
	    diode.setValue(0, oaFloat(data->antennaDiffAreaRatio()) / factor);
	
	} else if (factor > 0 && data->hasAntennaDiffAreaRatioPWL()) {
	    lefiAntennaPWL *pwl = data->antennaDiffAreaRatioPWL();

	    diode.setNumItems(pwl->numPWL());
	    for (oaInt4 i = 0; i < pwl->numPWL(); i++) {
		diode.setHeader(i, lefIn.uuToDBUArea(pwl->PWLdiffusion(i)));
		diode.setValue(i, oaFloat(pwl->PWLratio(i)) / factor);
	    }
	
	} else if (sideFactor > 0 && data->hasAntennaDiffSideAreaRatio()) {
	    diode.setNumItems(1);
	    diode.setHeader(0, 0);
	    diode.setValue(0, oaFloat(data->antennaDiffSideAreaRatio()) / sideFactor);
	    isSide = true;

	} else if (sideFactor > 0 && data->hasAntennaDiffSideAreaRatioPWL()) {
	    lefiAntennaPWL *pwl = data->antennaDiffSideAreaRatioPWL();

	    diode.setNumItems(pwl->numPWL());
	    for (oaInt4 i = 0; i < pwl->numPWL(); i++) {
		diode.setHeader(i, lefIn.uuToDBUArea(pwl->PWLdiffusion(i)));
		diode.setValue(i, oaFloat(pwl->PWLratio(i)) / sideFactor);
	    }

	    isSide = true;
	}


	// DIODE CUMULATIVE
	oa1DLookupTbl<oaInt8, oaFloat> cumDiode(0, "diodeAreaRatio", 0);

	if (factor > 0 && data->hasAntennaCumDiffAreaRatio()) {
	    cumDiode.setNumItems(1);
	    cumDiode.setHeader(0, 0);
	    cumDiode.setValue(0, oaFloat(data->antennaCumDiffAreaRatio()) / factor);

	} else if (factor > 0 && data->hasAntennaCumDiffAreaRatioPWL()) {
	    lefiAntennaPWL  *pwl = data->antennaCumDiffAreaRatioPWL();

	    cumDiode.setNumItems(pwl->numPWL());
	    for (oaInt4 i = 0; i < pwl->numPWL(); i++) {
		cumDiode.setHeader(i, lefIn.uuToDBUArea(pwl->PWLdiffusion(i)));
		cumDiode.setValue(i, oaFloat(pwl->PWLratio(i)) / factor);
	    }
	} else if  (sideFactor > 0 && data->hasAntennaCumDiffSideAreaRatio()) {
	    cumDiode.setNumItems(1);
	    cumDiode.setHeader(0, 0);
	    cumDiode.setValue(0, oaFloat(data->antennaCumDiffSideAreaRatio()) / sideFactor);
	    isSide = true;

	} else if (sideFactor > 0 && data->hasAntennaCumDiffSideAreaRatioPWL()) {
	    lefiAntennaPWL  *pwl = data->antennaCumDiffSideAreaRatioPWL();
		
	    cumDiode.setNumItems(pwl->numPWL());
	    for (oaInt4 i = 0; i < pwl->numPWL(); i++) {
		cumDiode.setHeader(i, lefIn.uuToDBUArea(pwl->PWLdiffusion(i)));
		cumDiode.setValue(i, oaFloat(pwl->PWLratio(i)) / sideFactor);
	    }
	}

	if (gate > 0 || diode.getNumItems()) {
	    ratios[(oaUInt4) model] = oaAntennaRatioValue::create(lefIn.tech(), 
								  isSide, gate,
								  diode);
	}

	if (cumGate > 0 || cumDiode.getNumItems()) {
	    cumRatios[(oaUInt4) model] = oaAntennaRatioValue::create(lefIn.tech(),
								     isSide,
								     cumGate,
								     cumDiode);
	}
    }


    if (ratios[0] || ratios[1] || ratios[2] || ratios[3]) {
	oaAntennaRatioArrayValue	*v
	    = oaAntennaRatioArrayValue::create(lefIn.tech(), ratios[0],
					       ratios[1], ratios[2], ratios[3]);

	lefIn.setConstraint(lefIn.getFoundryRules(), oacAntenna, 
			    layer->getNumber(), v);
    }

    if (cumRatios[0] || cumRatios[1] || cumRatios[2] || cumRatios[3]) {
	oaAntennaRatioArrayValue	*v
	    = oaAntennaRatioArrayValue::create(lefIn.tech(), cumRatios[0],
					       cumRatios[1], cumRatios[2],
					       cumRatios[3]);

	oaSimpleConstraintType type = layer->getMaterial() == oacMetalMaterial
				        ? oacCumMetalAntenna : oacCumViaAntenna;
	
	lefIn.setConstraint(lefIn.getFoundryRules(), type, v);
    }
}



// *****************************************************************************
// LefInLayer::parseProperties()
// 
// This function handles the PROPERTY attributes for the specified layer.
// *****************************************************************************
void
LefInLayer::parseProperties()
{
    LefDefProp	*propDef;

    for (int i = 0; i < lefLayer->numProps(); i++) {
	propDef = lefIn.getProp(lefLayer->propName(i), cLefDefLayer);
	lefIn.createProp(propDef, layer, lefLayer->propValue(i));
    }
}



// *****************************************************************************
// LefInLayer::parseACCurDen()
// LefInLayer::parseDCCurDen()
// 
// This function handles the current density attributes for the specified layer.
// ***************************