Merge pull request #2049 from KLayout/devel

Devel

Author: klayoutmatthias

src/db/db/dbCellVariants.cc

@@ -712,6 +712,28 @@ VariantsCollectorBase::create_var_instances_tl_invariant (db::Cell &in_cell, std
 
 // ------------------------------------------------------------------------------------------
 
+TransformationReducer *
+make_reducer (ReducerType type)
+{
+
+  switch (type) {
+  case Orientation:
+    return new OrientationReducer ();
+  case Orthogonal:
+    return new OrthogonalTransformationReducer ();
+  case Magnification:
+    return new MagnificationReducer ();
+  case XYAnisotropyAndMagnification:
+    return new XYAnisotropyAndMagnificationReducer ();
+  case MagnificationAndOrientation:
+    return new MagnificationAndOrientationReducer ();
+  default:
+    return 0;
+  }
+}
+
+// ------------------------------------------------------------------------------------------
+
 VariantStatistics::VariantStatistics ()
   : mp_red ()
 {

src/db/db/dbCellVariants.h

@@ -166,6 +166,51 @@ struct DB_PUBLIC ScaleAndGridReducer
   int64_t m_grid;
 };
 
+/**
+ *  @brief An enum describing a reducer type
+ *
+ *  This enum is used to create a generic reducer (parameterless) from the code.
+ */
+enum ReducerType
+{
+  /**
+   *  @brief No specific reducer
+   */
+  NoReducer = 0,
+
+  /**
+   *  @brief Rotation/mirror variants
+   */
+  Orientation = 1,
+
+  /**
+   *  @brief Orthogonal transformations (rotations of multiple of 90 degree) variants
+   */
+  Orthogonal = 2,
+
+  /**
+   *  @brief Scaling variants
+   */
+  Magnification = 3,
+
+  /**
+   *  @brief Scaling and x/y assymmetry variants (i.e. anisotropic size)
+   */
+  XYAnisotropyAndMagnification = 4,
+
+  /**
+   *  @brief Scaling and orientation variants
+   */
+  MagnificationAndOrientation = 5
+};
+
+/**
+ *  @brief Creates a TransformationReducer from the type enum
+ *
+ *  This function returns 0 if the type is NoReducer or invalid.
+ */
+DB_PUBLIC TransformationReducer *make_reducer (ReducerType type);
+
 /**
  *  @brief A class computing variants for cells according to a given criterion
  *

src/db/db/dbCompoundOperation.cc

@@ -302,7 +302,7 @@ CompoundTransformationReducer::is_translation_invariant () const
 
 // ---------------------------------------------------------------------------------------------
 
-CompoundRegionMultiInputOperationNode::CompoundRegionMultiInputOperationNode (const std::vector<CompoundRegionOperationNode *> &children)
+CompoundRegionMultiInputOperationNode::CompoundRegionMultiInputOperationNode (const std::vector<CompoundRegionOperationNode *> &children, bool no_init)
 {
   for (std::vector<CompoundRegionOperationNode *>::const_iterator c = children.begin (); c != children.end (); ++c) {
     (*c)->keep ();
@@ -362,6 +362,11 @@ CompoundRegionMultiInputOperationNode::init ()
   for (tl::shared_collection<CompoundRegionOperationNode>::iterator i = m_children.begin (); i != m_children.end (); ++i) {
     m_vars.add (i->vars ());
   }
+
+  //  add the local variant reducer
+  if (local_vars ()) {
+    m_vars.add (local_vars ());
+  }
 }
 
 CompoundRegionMultiInputOperationNode::~CompoundRegionMultiInputOperationNode ()

src/db/db/dbCompoundOperation.h

@@ -453,7 +453,7 @@ class DB_PUBLIC CompoundRegionMultiInputOperationNode
   : public CompoundRegionOperationNode
 {
 public:
-  CompoundRegionMultiInputOperationNode (const std::vector<CompoundRegionOperationNode *> &children);
+  CompoundRegionMultiInputOperationNode (const std::vector<CompoundRegionOperationNode *> &children, bool no_init = false);
   CompoundRegionMultiInputOperationNode ();
   CompoundRegionMultiInputOperationNode (CompoundRegionOperationNode *child);
   CompoundRegionMultiInputOperationNode (CompoundRegionOperationNode *a, CompoundRegionOperationNode *b);
@@ -521,14 +521,16 @@ class DB_PUBLIC CompoundRegionMultiInputOperationNode
   CompoundRegionOperationNode *child (unsigned int index);
   const CompoundRegionOperationNode *child (unsigned int index) const;
 
+  virtual const TransformationReducer *local_vars () const { return 0; }
+
+  void init ();
+
 private:
   tl::shared_collection<CompoundRegionOperationNode> m_children;
   //  maps child#,layer# to layer# of child:
   std::map<std::pair<unsigned int, unsigned int>, unsigned int> m_map_layer_to_child;
   std::vector<db::Region *> m_inputs;
   CompoundTransformationReducer m_vars;
-
-  void init ();
 };
 
 

src/db/db/dbLayoutToNetlistWriter.cc

@@ -692,6 +692,8 @@ void std_writer_impl<Keys>::write (TokenizedOutput &stream, const db::Net &net,
             *outp << tl::to_string (id);
             if (! net.name ().empty ()) {
               TokenizedOutput (*outp, Keys::name_key, true) << tl::to_word_or_quoted_string (net.name ());
+            } else if (net.id () != id) {
+              TokenizedOutput (*outp, Keys::name_key, true) << tl::to_word_or_quoted_string (net.expanded_name ());
             }
 
             *outp << endl;

src/db/db/dbNetlistCrossReference.cc

@@ -111,6 +111,24 @@ NetlistCrossReference::other_net_for (const db::Net *net) const
   }
 }
 
+const NetlistCrossReference::PerNetData *
+NetlistCrossReference::per_net_data_for_net (const db::Net *net) const
+{
+  const db::Net *other_net = other_net_for (net);
+
+  std::map<std::pair<const db::Net *, const db::Net *>, PerNetData>::iterator i = m_per_net_data.find (std::make_pair (net, other_net));
+  if (i == m_per_net_data.end ()) {
+    i = m_per_net_data.find (std::make_pair (other_net, net));
+  }
+
+  if (i == m_per_net_data.end ()) {
+    static const NetlistCrossReference::PerNetData empty_net_data;
+    return &empty_net_data;
+  } else {
+    return &i->second;
+  }
+}
+
 const NetlistCrossReference::PerNetData *
 NetlistCrossReference::per_net_data_for (const std::pair<const db::Net *, const db::Net *> &nets) const
 {

src/db/db/dbNetlistCrossReference.h

@@ -280,6 +280,7 @@ class DB_PUBLIC NetlistCrossReference
   const db::SubCircuit *other_subcircuit_for (const db::SubCircuit *subcircuit) const;
   const db::Circuit *other_circuit_for (const db::Circuit *circuit) const;
   const db::Net *other_net_for (const db::Net *net) const;
+  const PerNetData *per_net_data_for_net (const db::Net *net) const;
   const PerNetData *per_net_data_for (const std::pair<const db::Net *, const db::Net *> &nets) const;
 
   const db::Netlist *netlist_a () const

src/db/db/dbPolygonNeighborhood.cc

@@ -28,38 +28,42 @@ namespace db
 {
 
 PolygonNeighborhoodVisitor::PolygonNeighborhoodVisitor ()
-  : m_result_type (db::CompoundRegionOperationNode::ResultType::Edges)
+  : m_result_type (db::CompoundRegionOperationNode::ResultType::Edges), m_variant_type (db::NoReducer)
 {
   disconnect_outputs ();
 }
 
 void
-PolygonNeighborhoodVisitor::connect_output (Layout * /*layout*/, std::unordered_set<db::PolygonWithProperties> *polygons) const
+PolygonNeighborhoodVisitor::connect_output (Layout * /*layout*/, std::unordered_set<db::PolygonWithProperties> *polygons, const db::ICplxTrans &trans) const
 {
   disconnect_outputs ();
   mp_polygons = polygons;
+  m_trans = trans;
 }
 
 void
-PolygonNeighborhoodVisitor::connect_output (db::Layout *layout, std::unordered_set<db::PolygonRefWithProperties> *polygons) const
+PolygonNeighborhoodVisitor::connect_output (db::Layout *layout, std::unordered_set<db::PolygonRefWithProperties> *polygons, const db::ICplxTrans &trans) const
 {
   disconnect_outputs ();
   mp_layout = layout;
   mp_polygon_refs = polygons;
+  m_trans = trans;
 }
 
 void
-PolygonNeighborhoodVisitor::connect_output (db::Layout * /*layout*/, std::unordered_set<db::EdgeWithProperties> *edges) const
+PolygonNeighborhoodVisitor::connect_output (db::Layout * /*layout*/, std::unordered_set<db::EdgeWithProperties> *edges, const db::ICplxTrans &trans) const
 {
   disconnect_outputs ();
   mp_edges = edges;
+  m_trans = trans;
 }
 
 void
-PolygonNeighborhoodVisitor::connect_output (Layout * /*layout*/, std::unordered_set<db::EdgePairWithProperties> *edge_pairs) const
+PolygonNeighborhoodVisitor::connect_output (Layout * /*layout*/, std::unordered_set<db::EdgePairWithProperties> *edge_pairs, const db::ICplxTrans &trans) const
 {
   disconnect_outputs ();
   mp_edge_pairs = edge_pairs;
+  m_trans = trans;
 }
 
 void
@@ -76,10 +80,10 @@ void
 PolygonNeighborhoodVisitor::output_polygon (const db::PolygonWithProperties &poly)
 {
   if (mp_polygons) {
-    mp_polygons->insert (poly);
+    mp_polygons->insert (poly.transformed (m_trans));
   } else if (mp_polygon_refs) {
     tl_assert (mp_layout != 0);
-    mp_polygon_refs->insert (db::PolygonRefWithProperties (db::PolygonRef (poly, mp_layout->shape_repository ()), poly.properties_id ()));
+    mp_polygon_refs->insert (db::PolygonRefWithProperties (db::PolygonRef (poly.transformed (m_trans), mp_layout->shape_repository ()), poly.properties_id ()));
   } else {
     throw tl::Exception (tl::to_string (tr ("PolygonNeighborhoodVisitor is not configured for edge output (use 'result_type=Edges')")));
   }
@@ -91,7 +95,7 @@ PolygonNeighborhoodVisitor::output_edge (const db::EdgeWithProperties &edge)
   if (mp_edges == 0) {
     throw tl::Exception (tl::to_string (tr ("PolygonNeighborhoodVisitor is not configured for edge output (use 'result_type=Edges')")));
   }
-  mp_edges->insert (edge);
+  mp_edges->insert (edge.transformed (m_trans));
 }
 
 void
@@ -100,16 +104,22 @@ PolygonNeighborhoodVisitor::output_edge_pair (const db::EdgePairWithProperties &
   if (mp_edge_pairs == 0) {
     throw tl::Exception (tl::to_string (tr ("PolygonNeighborhoodVisitor is not configured for edge pair output (use 'result_type=EdgePairs')")));
   }
-  mp_edge_pairs->insert (edge_pair);
+  mp_edge_pairs->insert (edge_pair.transformed (m_trans));
 }
 
 // --------------------------------------------------------------------------------------------------
 
 PolygonNeighborhoodCompoundOperationNode::PolygonNeighborhoodCompoundOperationNode (const std::vector<CompoundRegionOperationNode *> &children, PolygonNeighborhoodVisitor *visitor, db::Coord dist)
-  : CompoundRegionMultiInputOperationNode (children), m_dist (dist), mp_visitor (visitor)
+  : CompoundRegionMultiInputOperationNode (children, true /*no implicit init()*/),
+    m_dist (dist), mp_visitor (visitor)
 {
   tl_assert (visitor != 0);
   visitor->keep ();
+
+  m_vars.reset (db::make_reducer (visitor->variant_type ()));
+
+  //  must be called after local_vars() is available
+  init ();
 }
 
 db::Coord
@@ -170,12 +180,19 @@ PolygonNeighborhoodCompoundOperationNode::compute_local_impl (CompoundRegionOper
   tl_assert (interactions.num_subjects () == 1);
   tl_assert (! results.empty ());
 
+  db::ICplxTrans var_trans, var_trans_inv;
+  if (proc->vars ()) {
+    var_trans_inv = proc->vars ()->single_variant_transformation (cell->cell_index ());
+    var_trans = var_trans_inv.inverted ();
+  }
+
   try {
 
-    mp_visitor->connect_output (layout, &results.front ());
+    mp_visitor->connect_output (layout, &results.front (), var_trans_inv);
 
     const T &pr = interactions.begin_subjects ()->second;
     db::PolygonWithProperties subject (pr.instantiate (), pr.properties_id ());
+    subject.transform (var_trans);
 
     PolygonNeighborhoodVisitor::neighbors_type neighbors;
 
@@ -191,6 +208,7 @@ PolygonNeighborhoodCompoundOperationNode::compute_local_impl (CompoundRegionOper
 
       for (auto p = others.front ().begin (); p != others.front ().end (); ++p) {
         n.push_back (db::PolygonWithProperties (p->instantiate (), p->properties_id ()));
+        n.back ().transform (var_trans);
       }
 
     }

src/db/db/dbPolygonNeighborhood.h

@@ -58,22 +58,22 @@ class DB_PUBLIC PolygonNeighborhoodVisitor
   /**
    *  @brief Configure the polygon output
    */
-  void connect_output (db::Layout * /*layout*/, std::unordered_set<db::PolygonWithProperties> *polygons) const;
+  void connect_output (db::Layout * /*layout*/, std::unordered_set<db::PolygonWithProperties> *polygons, const db::ICplxTrans &trans) const;
 
   /**
    *  @brief Configure the polygon ref output
    */
-  void connect_output (db::Layout *layout, std::unordered_set<db::PolygonRefWithProperties> *polygons) const;
+  void connect_output (db::Layout *layout, std::unordered_set<db::PolygonRefWithProperties> *polygons, const db::ICplxTrans &trans) const;
 
   /**
    *  @brief Configure the edge output
    */
-  void connect_output (db::Layout * /*layout*/, std::unordered_set<db::EdgeWithProperties> *edges) const;
+  void connect_output (db::Layout * /*layout*/, std::unordered_set<db::EdgeWithProperties> *edges, const db::ICplxTrans &trans) const;
 
   /**
    *  @brief Configure the edge pair output
    */
-  void connect_output (db::Layout * /*layout*/, std::unordered_set<db::EdgePairWithProperties> *edge_pairs) const;
+  void connect_output (db::Layout * /*layout*/, std::unordered_set<db::EdgePairWithProperties> *edge_pairs, const db::ICplxTrans &trans) const;
 
   /**
    *  @brief Disconnects output
@@ -102,6 +102,22 @@ class DB_PUBLIC PolygonNeighborhoodVisitor
     return m_result_type;
   }
 
+  /**
+   *  @brief Sets the variant type
+   */
+  void set_variant_type (db::ReducerType variant_type)
+  {
+    m_variant_type = variant_type;
+  }
+
+  /**
+   *  @brief Gets the variant type
+   */
+  db::ReducerType variant_type () const
+  {
+    return m_variant_type;
+  }
+
   /**
    *  @brief Delivers a polygon
    *  This function is only permitted if the result type is Region.
@@ -122,11 +138,13 @@ class DB_PUBLIC PolygonNeighborhoodVisitor
 
 private:
   db::CompoundRegionOperationNode::ResultType m_result_type;
+  db::ReducerType m_variant_type;
   mutable std::unordered_set<db::PolygonWithProperties> *mp_polygons;
   mutable std::unordered_set<db::PolygonRefWithProperties> *mp_polygon_refs;
   mutable std::unordered_set<db::EdgeWithProperties> *mp_edges;
   mutable std::unordered_set<db::EdgePairWithProperties> *mp_edge_pairs;
   mutable db::Layout *mp_layout;
+  mutable db::ICplxTrans m_trans;
 };
 
 /**
@@ -148,6 +166,11 @@ class DB_PUBLIC PolygonNeighborhoodCompoundOperationNode
     return false;
   }
 
+  virtual const TransformationReducer *local_vars () const
+  {
+    return m_vars.get ();
+  }
+
 protected:
   virtual db::Coord computed_dist () const;
   virtual std::string generated_description () const;
@@ -162,6 +185,7 @@ class DB_PUBLIC PolygonNeighborhoodCompoundOperationNode
 private:
   db::Coord m_dist;
   tl::weak_ptr<PolygonNeighborhoodVisitor> mp_visitor;
+  std::unique_ptr<db::TransformationReducer> m_vars;
 
   template <class T, class TR>
   void compute_local_impl (CompoundRegionOperationCache * /*cache*/, db::Layout * /*layout*/, db::Cell * /*cell*/, const shape_interactions<T, T> & /*interactions*/, std::vector<std::unordered_set<TR> > & /*results*/, const db::LocalProcessorBase * /*proc*/) const;