Trace hierarchy of cell (schematic view) without open

 I'll post a couple of bits of code which might be useful:

/* abLibraryRefs.il

Author     A.D.Beckett
Group      Structured Custom, Cadence Design Systems Ltd.
Machine    SUN
Date       Aug 16, 1996 
Modified   Sep 05, 2013 
By         A.D.Beckett

Get a list of cells, the views, and cells instantated

Main entry point is abLibraryRefs(libName)

Updated Sept 2013 since previous code was for 4.3.4!

***************************************************

SCCS Info: @(#) abLibraryRefs.il 03/11/22.16:37:26 1.3

*/


/***************************************************************
*                                                              *
*          (abGetCellViewRefs lib cellName viewName)           *
*                                                              *
*     Get a list of all the libName/cellName pairs used in     *
*                         a cellView.                          *
*                                                              *
***************************************************************/

(procedure (abGetCellViewRefs lib cellName viewName)
  (let (cellView refList libCell)
       (when (setq cellView (dbOpenCellView lib cellName viewName))
             /* use instances rather than instanceMasters because it
             will then work if the library/cell for the instance can't be
             opened */
             (foreach instance (dbGetq cellView instances)
                      (setq libCell
                            (list (dbGetq instance libName) 
                                  (dbGetq instance cellName)))
                      (unless (member libCell refList)
                              (setq refList (cons libCell refList)))
                      )
             /* sorting is to make the result prettier! */
             (setq refList (sortcar refList 'alphalessp))
             (dbClose cellView))
       refList))

/**********************************************************************
*                                                                     *
*                       (abLibraryRefs libName)                       *
*                                                                     *
*      Return a list of lists, with the name of the cell at the       *
*  head of each sublist, and the second item being a list of views.   *
*  Each view list contains the name of the view, followed by a list   *
* of library name/cell name pairs for instances within that cellView. *
*                                                                     *
**********************************************************************/

(procedure (abLibraryRefs libName)
  (let (lib refList)
       (setq lib (ddGetObj libName))
       (if lib
         (setq refList
               /* loop through all the cells */
               (foreach mapcar cell (getq lib cells)
                        (cons (getq cell name)
                              /* sort the views to make them look better */
                              (sortcar
                                /* loop through all the views */
                                (foreach mapcar cellview (getq cell views)
                                         (cons (dbGetq cellview name)
                                               /* get the list of references inside the cellView */
                                               (abGetCellViewRefs
                                                 lib
                                                 (dbGetq cell name)
                                                 (dbGetq cellview name))))
                                         'alphalessp)))
               )
           /* else give a message */
           (error "Could not open library %s" libName))
       refList
       ))


/***************************************************************
*                                                              *
*                  (abLibrariesUsed refList)                   *
*                                                              *
*      Take the reference list returned by the above, and      *
*               return a list of libraries used                *
*                                                              *
***************************************************************/

(procedure (abLibrariesUsed refList)
  (let (libsUsed)
       (foreach cell refList
                (foreach view (cdr cell)
                         (foreach reference (cdr view)
                                  (unless (member (car reference) libsUsed)
                                          (setq libsUsed (cons (car reference)
                                                               libsUsed))
                                          ))))
       libsUsed))

And the second one:

/* abNewLibraryRefs.il

Author     A.D.Beckett
Group      Custom IC (UK), Cadence Design Systems Ltd.
Language   SKILL
Date       Jan 12, 1999 
Modified   Feb 19, 2003 
By         A.D.Beckett

Uses the new ccpExpand facilities to expand library data,
either using the pc.db files (parent child databases),
or using config files to find all the cellViews or libraries
used. This is quicker than opening databases, and also supports
configurations.

Each of the four functions can be used externally.

***************************************************

SCCS Info: @(#) abNewLibraryRefs.il 01/03/18.17:40:58 1.3

*/

/****************************************************************
*                                                               *
*    (abNewCellViewRefs libName cellName viewName @optional     *
*              (expandMode 'CCP_EXPAND_COMANAGED))              *
*                                                               *
*  Expand the specified cellView, returning a list of lists of  *
*  cellView information. The expandMode is the keyword to pass  *
*  to ccpExpand.* functions to say what files to include. The   *
* default should be adequate for most cases. The expansion will *
*   follow through the complete design hierarchy, into other    *
*  libraries, since it uses the pc.db and config information.   *
*                                                               *
****************************************************************/

(procedure (abNewCellViewRefs libName cellName viewName @optional
                              (expandMode 'CCP_EXPAND_COMANAGED))
  (let (spec expanded cellViews cellViewInfo obj)
       (setq obj (ddGetObj libName cellName viewName))
       (setq spec (gdmCreateSpecFromDDID obj))
       (setq expanded
             (cond 
              ((ddGetObj libName cellName viewName "pc.db")
               (ccpExpandDesign spec expandMode))
              ((ddGetObj libName cellName viewName "*.oa")
               (ccpExpandDesign spec expandMode))
              ((ddGetObj libName cellName viewName "expand.cfg")
               (ccpExpandConfig spec expandMode))
              (t
               (setq specList (gdmCreateSpecList))
               (gdmAddSpecToSpecList spec specList)
               (ccpExpand specList expandMode))
              ))
       (gdmResetSpecList expanded)
       (while (setq spec (gdmNextFromSpecList expanded))
              (when (and
                     (setq cellViewInfo (gdmInspectSpec spec "LibraryUnix"))
                     (equal (cadddr cellViewInfo) "master.tag"))
                    (rplacd (cddr cellViewInfo) nil)
                    (setq cellViews (cons cellViewInfo cellViews))
                    )
              )
       cellViews
       ))

/**********************************************************************
*                                                                     *
*             (abNewLibraryRefs libName @optional sorted)             *
*                                                                     *
*  Get all cellViews in a library, invoke abNewCellViewRefs on them,  *
*     and then collate the information into a list of lists. The      *
* optional argument is a flag to indicate that the information should *
*                             be sorted.                              *
*                                                                     *
**********************************************************************/

(procedure (abNewLibraryRefs libName @optional sorted)
  (let (libObj cellViews cellViewTable)
       (unless
        (setq libObj (ddGetObj libName))
        (error "Could not open library %s\n" libName)
        )
       /* create a table - easy way of removing duplicates */
       (setq cellViewTable (makeTable 'cellViewTable))
       /* visit all cells */
       (foreach cell (getq libObj cells)
                /* visit all cellViews */
                (foreach view (getq cell views)
                         /* get all the references, even through other libs */
                         (setq cellViews 
                               (abNewCellViewRefs
                                libName (getq cell name) (getq view name)))
                         /* record any cellViews used in the table */
                         (foreach cellView cellViews
                                  (setarray cellViewTable cellView t))
                         ))
       /* pull out everything from the table */
       (setq cellViews nil)
       (foreach cellView cellViewTable
                (setq cellViews (cons cellView cellViews)))
       /* if sorted has been supplied and set to non-nil, sort the
          list before returning it */
       (when sorted
             (setq cellViews
                   (sort cellViews 
                         /* comparison function - sorts strings in lists */
                         (lambda (a b)
                                 (while (and
                                         (car a) (car b)
                                         (equal (car a) (car b)))
                                        (setq a (cdr a))
                                        (setq b (cdr b)))
                                 (and (car a) (car b) 
                                      (alphalessp (car a) (car b)))
                                 ))
                   ))
       cellViews
       ))

/*************************************************************************
*                                                                        *
*                      (abNewLibrariesUsed libName)                      *
*                                                                        *
* Process the library, expand the design hierarchies and configurations, *
*   and find out all the libraries referenced, directly or indirectly.   *
*                                                                        *
*************************************************************************/

(procedure (abNewLibrariesUsed libName)
  (let (libs)
       (foreach cellView (abNewLibraryRefs libName)
                (unless (member (car cellView) libs)
                        (setq libs (cons (car cellView) libs))))
       libs
       ))

/****************************************************************************
*                                                                           *
*         (abNewLibrariesUsedByCellView libName cellName viewName)          *
*                                                                           *
* Process the cellView, expanding the hierarchy, and find out all libraries *
*                    referenced, directly or indirectly.                    *
*                                                                           *
****************************************************************************/

(procedure (abNewLibrariesUsedByCellView libName cellName viewName)
  (let (libs)
       (foreach cellView (abNewCellViewRefs libName cellName viewName)
                (unless (member (car cellView) libs)
                        (setq libs (cons (car cellView) libs))))
       libs
       ))

These might not be quite what you want, but maybe they'll help get you started...

Andrew.

 Thanks Andrew,

I will try them.

Best regards,

tyanata