oalefinpin.cpp

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

    oaAntennaAreaArray gateAreaArray(lefPin->numAntennaSize());
    oaAntennaAreaArray diffAreaArray(lefPin->numAntennaSize());
    for (i = 0; i < lefPin->numAntennaSize(); i++) {
	if (lefPin->antennaSize(i) > 0) {
	    // Map to Antenna Gate Area
	    if (term->getTermType() != oacInputTermType) {
		throw LefDefError(cPinAntennaSizePos, lefPin->name());
	    }
	    
	    oaUInt8 area(lefIn.uuToDBUArea(lefPin->antennaSize(i)));
	    
	    if (lefPin->antennaSizeLayer(i)) {
		oaLayerNum num(lefIn.getLayerNum(lefPin->antennaSizeLayer(i)));
		gateAreaArray.append(oaAntennaArea(area, num));
	    } else {
		gateAreaArray.append(oaAntennaArea(area));
	    }
	} else {
	    // Map to Antenna Diff Area (invert sign)
	    oaUInt8 area(lefIn.uuToDBUArea(-lefPin->antennaSize(i)));
	    
	    if (lefPin->antennaSizeLayer(i)) {
		oaLayerNum num(lefIn.getLayerNum(lefPin->antennaSizeLayer(i)));
		diffAreaArray.append(oaAntennaArea(area, num));
	    } else {
		diffAreaArray.append(oaAntennaArea(area));
	    }
	}    
    }
    data.gate() = gateAreaArray;	   
    data.diff() = diffAreaArray;
    
    // Antenna Metal Area (map to Antenna Partial Metal Area)
    oaAntennaAreaArray partialMetalArray(lefPin->numAntennaMetalArea());
    for (i = 0; i < lefPin->numAntennaMetalArea(); i++) {
	if (lefPin->antennaMetalArea(i) < 0) {
	    throw LefDefError(cPinAntennaAreaNeg, lefPin->name());
	}

	oaUInt8 area(lefIn.uuToDBUArea(lefPin->antennaMetalArea(i)));
	
	if (lefPin->antennaMetalAreaLayer(i)) {
	    oaLayerNum num(lefIn.getLayerNum(lefPin->antennaMetalAreaLayer(i)));
	    partialMetalArray.append(oaAntennaArea(area, num));
	} else {
	    partialMetalArray.append(oaAntennaArea(area));
	}
    }
    data.partialMetal() = partialMetalArray;
    
    // Antenna Metal Length (Map to Antenna Partial Metal Side Area)
    //  (multiply by layer thickness)
    oaAntennaAreaArray
	partialMetalSideArray(lefPin->numAntennaMetalLength());
    for (i = 0; i < lefPin->numAntennaMetalLength(); i++) {
	if (lefPin->antennaMetalLength(i) < 0) {
	    throw LefDefError(cPinAntennaLengthNeg, lefPin->name());
	}

	if (!lefPin->antennaMetalLengthLayer(i)) {
	    throw LefDefError(cPinAntennaNoLayer, lefPin->name());
	}
	
	oaLayer	    *layer = lefIn.getLayer(lefPin->antennaMetalLengthLayer(i));
	oaIntProp   *prop = (oaIntProp *) oaProp::find(layer,
						       cLefLayerThickness);
	if (!prop) {
	    throw LefDefError(cPinAntennaLayerCannotFindThickness,
			      lefPin->name(),
			      lefPin->antennaMetalLengthLayer(i));
	}
	
	oaUInt4 thickness(prop->getValue());
	oaUInt8 area(lefIn.uuToDBU(lefPin->antennaMetalLength(i))
		     * thickness);
	partialMetalSideArray.append(oaAntennaArea(area,
						   layer->getNumber()));
    }

    data.partialMetalSide() = partialMetalSideArray;
    
    term->setAntennaData(data);
}	



// *****************************************************************************
// LefInPin::parseAntenna54()
//
// This function handles the pin antenna attributes, in 5.4 syntax
// *****************************************************************************
void
LefInPin::parseAntenna54()
{ 
    // always parse generic data for defaultAntennaModel
    oaAntennaData data(oacDefaultAntennaModel);
    if (term->isAntennaDataSet(oacDefaultAntennaModel)) {
	term->getAntennaData(data, oacDefaultAntennaModel);
    }
    parseAntennaGeneric(data);
    term->setAntennaData(data);

    // parse model specific antenna data
    for (oaInt4 j(0); j < lefPin->numAntennaModel(); j++) {
	oaString	    s(lefPin->antennaModel(j)->antennaOxide());
	oaAntennaModelEnum  antennaModel(oacDefaultAntennaModel);

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

	oaAntennaData data(antennaModel);

	if (term->isAntennaDataSet(antennaModel)) {
	    term->getAntennaData(data, antennaModel);
	}

	parseAntennaGeneric(data);
	parseAntennaModel(data, j);

	term->setAntennaData(data);
    }
}

void
LefInPin::parseAntennaGeneric(oaAntennaData &data)
{

    oaUInt4 i(0);    
    // ANTENNAPINPARTIALMETALAREA
    oaUInt4 num(lefPin->numAntennaPartialMetalArea());
    if (num) {
	data.partialMetal().setSize(num, false); // overwrite
	data.partialMetal().setNumElements(0);
	for (i = 0; i < num; i++) {
	    oaUInt8 area 
                = lefIn.uuToDBUArea(lefPin->antennaPartialMetalArea(i));
	    if (lefPin->antennaPartialMetalAreaLayer(i)) {
		oaLayerNum layer(lefIn.getLayerNum(lefPin->antennaPartialMetalAreaLayer(i)));
		data.partialMetal().append(oaAntennaArea(area, layer));
	    } else {
		data.partialMetal().append(oaAntennaArea(area));	    
	    }
	}
	data.partialMetal().compress();
    }
	
    // ANTENNAPINPARTIALMETALSIDEAREA
    num = lefPin->numAntennaPartialMetalSideArea();
    if (num) {
	data.partialMetalSide().setSize(num, false); // overwrite
	data.partialMetalSide().setNumElements(0);
	for (i = 0; i < num; i++) {
	    oaUInt8 area 
                = lefIn.uuToDBUArea(lefPin->antennaPartialMetalSideArea(i));
	    if (lefPin->antennaPartialMetalSideAreaLayer(i)) {
		oaLayerNum layer(lefIn.getLayerNum(lefPin->antennaPartialMetalSideAreaLayer(i)));
		data.partialMetalSide().append(oaAntennaArea(area, layer));
	    } else {
		data.partialMetalSide().append(oaAntennaArea(area));
	    }
	}
	data.partialMetalSide().compress();
    }
	
    // ANTENNAPINDIFFAREA
    num = lefPin->numAntennaDiffArea();
    if (num) {
	data.diff().setSize(num, false); // overwrite
	data.diff().setNumElements(0);
	for (i = 0; i < num; i++) {
	    oaUInt8 area
                = lefIn.uuToDBUArea(lefPin->antennaDiffArea(i));
	    if (lefPin->antennaDiffAreaLayer(i)) {
		oaLayerNum layer(lefIn.getLayerNum(lefPin->antennaDiffAreaLayer(i)));
		data.diff().append(oaAntennaArea(area, layer));
	    } else {
		data.diff().append(oaAntennaArea(area));
	    }
	}
	data.diff().compress();
    }


    // ANTENNAPINPARTIALCUTAREA
    num = lefPin->numAntennaPartialCutArea();
    if (num) {
	data.partialCut().setSize(num, false); // overwrite
	data.partialCut().setNumElements(0);
	for (i = 0; i < num; i++) {
	    oaUInt8 area
                = lefIn.uuToDBUArea(lefPin->antennaPartialCutArea(i));
	    if (lefPin->antennaPartialCutAreaLayer(i)) {
		oaLayerNum layer(lefIn.getLayerNum(lefPin->antennaPartialCutAreaLayer(i)));
		data.partialCut().append(oaAntennaArea(area, layer));
	    } else {
		data.partialCut().append(oaAntennaArea(area));
	    }
	}
	data.partialCut().compress();
    }
}

void
LefInPin::parseAntennaModel(oaAntennaData   &data,
			    oaUInt4	    model)
{
    oaUInt4 i(0);

    // ANTENNAPINGATEAREA
    oaUInt4 num(lefPin->antennaModel(model)->numAntennaGateArea());
    if (num) {
	data.gate().setSize(num, false); // overwrite
	data.gate().setNumElements(0);
	for (i = 0; i < num; i++) {
	    oaUInt8 area = lefIn.uuToDBUArea(lefPin->antennaModel(model)
						   ->antennaGateArea(i));
	    if (lefPin->antennaModel(model)->antennaGateAreaLayer(i)) {
		oaLayerNum layer(lefIn.getLayerNum(lefPin->antennaModel(model)
							 ->antennaGateAreaLayer(i)));
		data.gate().append(oaAntennaArea(area, layer));
	    } else {
		data.gate().append(oaAntennaArea(area));
	    }
	}
	data.gate().compress();
    }
	    
    
    // ANTENNAPINMAXAREACAR
    num = lefPin->antennaModel(model)->numAntennaMaxAreaCar();
    if (num) {
	data.maxCAR().setSize(num, false); // overwrite
	data.maxCAR().setNumElements(0);
	for (i = 0; i < num; i++) {
	    oaUInt8 area = lefIn.uuToDBUArea(lefPin->antennaModel(model)
						   ->antennaMaxAreaCar(i));
	    oaLayerNum layer(lefIn.getLayerNum(lefPin->antennaModel(model)
						     ->antennaMaxAreaCarLayer(i)));
	    data.maxCAR().append(oaAntennaArea(area, layer));
	}
	data.maxCAR().compress();
    }
	    
    // ANTENNAPINMAXSIDEAREACAR
    num = lefPin->antennaModel(model)->numAntennaMaxSideAreaCar();
    if (num) {
	data.maxSideCAR().setSize(num, false); // overwrite
	data.maxSideCAR().setNumElements(0);
	for (i = 0; i < num; i++) {
	    oaUInt8 area = lefIn.uuToDBUArea(lefPin->antennaModel(model)
						   ->antennaMaxSideAreaCar(i));
	    oaLayerNum layer(lefIn.getLayerNum(lefPin->antennaModel(model)
						     ->antennaMaxSideAreaCarLayer(i)));
	    data.maxSideCAR().append(oaAntennaArea(area, layer));
	}
	data.maxSideCAR().compress();
    }
	    
    // ANTENNAPINMAXCUTCAR
    num = lefPin->antennaModel(model)->numAntennaMaxCutCar();
    if (num) {
	data.maxCutCAR().setSize(num, false); // overwrite
	data.maxCutCAR().setNumElements(0);
	for (i = 0; i < num; i++) {
	    oaUInt8 area = lefIn.uuToDBUArea(lefPin->antennaModel(model)
						   ->antennaMaxCutCar(i));
	    oaLayerNum layer(lefIn.getLayerNum(lefPin->antennaModel(model)
						     ->antennaMaxCutCarLayer(i)));
	    data.maxCutCAR().append(oaAntennaArea(area, layer));
	}
	data.maxCutCAR().compress();
    }
}



// *****************************************************************************
// LefInPin::createTerm()
//
// This function creates a new terminal with the name from the LEF pin.
// *****************************************************************************
oaTerm*
LefInPin::createTerm()
{
    oaSimpleName    pinName(lefIn.getNS(), lefPin->name());
    oaTerm	    *pinTerm = oaTerm::find(lefIn.topBlock(), pinName);

    if (pinTerm) {
	term = (oaBitTerm*) pinTerm;
	return term;
    }

    oaBlockDomainVisibility visibility = oacInheritFromTopBlock;

    if (lefPin->hasMustjoin()) {
	visibility = oacExcludeFromModuleDomain;
    }

    switch (pinName.getType()) {
      case oacScalarNameType:
	term = oaScalarTerm::create(getNet(), *pinName.getScalar(),
				    oacInputTermType, visibility);
	break;

      case oacVectorBitNameType:
	term = oaBusTermBit::create((oaBitNet*) getNet(),
				    *pinName.getVectorBit(),
				    oacInputTermType, visibility);
	break;
    }
 
    return term;
}



// *****************************************************************************
// LefInPin::getNet()
//
// This function returns the block domain net for this LEF pin, creating it if
// it doesn't exist.
// *****************************************************************************
oaBitNet*
LefInPin::getNet()
{ 
    oaBitNet	    *net = NULL;
    oaSimpleName    netName(lefIn.getNS(), lefPin->name());

    switch (netName.getType()) {
      case oacScalarNameType:
	{
	    net = oaScalarNet::find(lefIn.topBlock(), *netName.getScalar());
		
	    if (!net) {
		net = oaScalarNet::create(lefIn.topBlock(),
					  *netName.getScalar(),
					  oacSignalSigType, false);
	    }
	}
	break;

      case oacVectorBitNameType:
	{
	    net = (oaBitNet*) oaNet::find(lefIn.topBlock(),
					  *netName.getVectorBit());
	
	    if (!net) {
		net = oaBusNetBit::create(lefIn.topBlock(),
					  *netName.getVectorBit(),
					  oacSignalSigType, false);
	    }
	}
	break;
    }

    return net;
}



END_LEFDEF_NAMESPACE