CellUniqueId.cxx

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
/// \file  CellUniqueId.cxx
/// \brief Give every cell in the geometry a unique ID number based on
///        the TGeo path to the node
///
/// \version $Id: CellUniqueId.cxx,v 1.2 2012-09-20 21:42:43 greenc Exp $
/// \author messier@indiana.edu
////////////////////////////////////////////////////////////////////////
#include "GeometryObjects/CellUniqueId.h"

#include <iostream>
#include "TGeoNode.h"
#include <cstdlib>
#include <climits>
#include <unordered_map>

namespace geo {

  //....................................................................

  CellUniqueId NodesToUniqueId(const std::vector<const TGeoNode*>& n,
                               unsigned int depth)
  {
    // Only the last seven levels are required for uniqueness. Avoid overflowing
    // the CellUniqueId.
    const unsigned int nlvl = 6;
    if(depth < nlvl) return 0;

    // There are only a handful of unique node pointers, store them here
    static std::unordered_map<const TGeoNode*, int> nodemap;

    CellUniqueId id = 0;
    for(unsigned int i = depth-nlvl; i <= depth; ++i){
      auto it = nodemap.find(n[i]);
      if(it == nodemap.end()){
        //will be adding new index to the map
        int mapsize = nodemap.size()+1;
        nodemap[n[i]] = mapsize;
        id += mapsize;
        // In testing (2018/01/26) it was 141.
        // In testing (2018/01/30) it was 255
        if(nodemap.size() == 512){
          std::cout << "NodesToUniqueId: Number of unique TGeoNodes exceeds 511."
                    << " Need to fix the logic here. Abort." << std::endl;
          abort();
        }
      }
      else{
        id += it->second;
      }

      if(id > ULLONG_MAX/512){
        std::cout << "NodesToUniqueId: overflow" << std::endl;
        abort();
      }
      id *= 512;
    } // end for i
    return id+1; // ensure result is always nonzero

    // This is the old code, but as of the root6 upgrade, the paths are all
    // like vPlaneV_0/vModuleV_0/vExtruV_0/vCellV_0 rather than
    // vPlaneV_3/vModuleV_1/vExtruV_4/vCellV_1, so we use the list of parent
    // pointers to determine the unique ID instead.
    /*
    static std::vector<int> ids;
    ids.clear();
    for (unsigned int i=0; i<=depth; ++i) {
      GetNodeNumbers(n[i]->GetName(), ids);
    }
    return IdsToUniqueId(ids);
    */
  }

  //....................................................................

  // Comment out all of these functions. Now that paths can't be relied upon
  // (after the root6 upgrade) these are all just foot-guns

  /*
  CellUniqueId PathToUniqueId(const char* path)
  {
    static std::vector<int> ids;
    ids.clear();
    GetNodeNumbers(path, ids);
    return IdsToUniqueId(ids);
  }

  //....................................................................

  CellUniqueId IdsToUniqueId(const std::vector<int>& ids)
  {
    CellUniqueId id = 0ULL;

    // Experience has shown that only depths below this "depth0"
    // contribute to a cell's 'uniqueness'. need 6 levels to
    // fill up the CellUniqueId
    static const unsigned int nlvl = 6;
    if(ids.size() < nlvl){
      return id;
    }
    unsigned int depth0 = ids.size() - nlvl;

    // Now construct the id
    for (unsigned int i=depth0; i<ids.size(); ++i) {
      // The following check is useful, although not really
      // required. The code in Geometry.cxx checks that the ID's are
      // unique which is all that really matters. Even if we happen to
      // overflow the storage limits of the CellUniqueId, the result
      // will always be the same for the same cell. So, as long as the
      // overflow is unique, all is OK. BTW, I've checked that as of
      // at least v1.6 2008/08/17 the CellUniqueID's do not overflow
      //
      // if (id>0 && ULLONG_MAX/id < 1000) abort();
      id = 1000*id + ids[i];
    }

    return id;
  }

  //....................................................................
  // the path is of the form /vDetEnclosure_1/vSuperBlockND_479/vBlockND_476/vPlaneH_422/vModuleH_420/vExtruH_381/vCellH_371 so search from the end to the beginning for the node numbers
  //
  void GetNodeNumbers(const char* nm, std::vector<int>& id)
  {
    char buff[8];
    const char* c;
    const char* start = nm;
    const char* end;
    int indx;

    while (1) {
      start = strchr(start, '_');
      if (start == NULL) break;
      ++start;
      end = strchr(start, '/');
      if (end==NULL) end = strchr(start, '\0');
      if (end==NULL) abort();

      for (indx=0, c=start; c<end; ++indx, ++c) buff[indx] = *c;
      buff[indx] = '\0';

      id.push_back(atoi(buff));
    }
  }
  */
}
////////////////////////////////////////////////////////////////////////