Geant4 LXR

Cross-Referencing   Geant4
Geant4/processes/electromagnetic/dna/management/src/G4KDMap.cc

   //
   // ********************************************************************
   // * License and Disclaimer                                           *
   // *                                                                  *
   // * The  Geant4 software  is  copyright of the Copyright Holders  of *
   // * the Geant4 Collaboration.  It is provided  under  the terms  and *
   // * conditions of the Geant4 Software License,  included in the file *
   // * LICENSE and available at  http://cern.ch/geant4/license .  These *
   // * include a list of copyright holders.                             *
  // *                                                                  *
  // * Neither the authors of this software system, nor their employing *
  // * institutes,nor the agencies providing financial support for this *
  // * work  make  any representation or  warranty, express or implied, *
  // * regarding  this  software system or assume any liability for its *
  // * use.  Please see the license in the file  LICENSE  and URL above *
  // * for the full disclaimer and the limitation of liability.         *
  // *                                                                  *
  // * This  code  implementation is the result of  the  scientific and *
  // * technical work of the GEANT4 collaboration.                      *
  // * By using,  copying,  modifying or  distributing the software (or *
  // * any work based  on the software)  you  agree  to acknowledge its *
  // * use  in  resulting  scientific  publications,  and indicate your *
  // * acceptance of all terms of the Geant4 Software license.          *
  // ********************************************************************
  //
  #include "G4KDMap.hh"
  #include "globals.hh"
  #include "G4KDNode.hh"
  #include <algorithm>
  
  using namespace std;
  
  using _deq_iterator = std::deque<G4KDNode_Base *>::iterator;
  
  G4bool __1DSortOut::sortOutNDim::operator()(G4KDNode_Base* const & lhs,
                                              G4KDNode_Base* const & rhs) //const
  {
    return (*lhs)[fDimension] < (*rhs)[fDimension];
  }
  
  __1DSortOut::__1DSortOut(std::size_t dimension) :
      fSortOutNDim(dimension)
  {
  }
  
  __1DSortOut::__1DSortOut(const __1DSortOut& right)  
  = default;
  
  G4int __1DSortOut::GetDimension()
  {
    return (G4int)fSortOutNDim.fDimension;
  }
  
  G4KDNode_Base* __1DSortOut::GetMidle(std::size_t& main_middle)
  {
    std::size_t contSize = fContainer.size();
    main_middle = (std::size_t) ceil(contSize / 2.); // ceil = round up
    return fContainer[main_middle];
  }
  
  _deq_iterator __1DSortOut::Insert(G4KDNode_Base* pos)
  {
    return fContainer.insert(fContainer.end(), pos);
  }
  
  G4KDNode_Base* __1DSortOut::PopOutMiddle()
  {
    std::size_t middle;
    G4KDNode_Base* pos = GetMidle(middle);
    auto deq_pos = fContainer.begin() + middle;
  
    if(deq_pos == fContainer.end()) return nullptr; // this is a double check
  
    fContainer.erase(deq_pos);
    return pos;
  }
  
  void __1DSortOut::Sort()
  {
    sort(fContainer.begin(), fContainer.end(), fSortOutNDim);
  }
  
  void __1DSortOut::Erase(_deq_iterator& deq_pos)
  {
    fContainer.erase(deq_pos);
  }
  
  void G4KDMap::Insert(G4KDNode_Base* pos)
  {
    vector<_deq_iterator>& vit = fMap[pos];
  
    std::size_t maxSize = fSortOut.size();
  
    G4cout << "G4KDMap::Insert : " << maxSize << G4endl;
  
    vit.reserve(maxSize);
  
    for (std::size_t i = 0; i < fSortOut.size(); ++i)
    {
     vit[i] = fSortOut[i].Insert(pos);
 
 //    if(*(vit[i]) != pos)
 //    {
 //      G4cout << "insert wrong iterator" << G4endl;
 //      abort();
 //    }
   }
   /*
    std::map<G4KDNode*, std::vector<_deq_iterator> >::iterator fMap_it
    = fMap.begin();
 
    for( ; fMap_it != fMap.end() ; fMap_it++)
    {
    std::vector<_deq_iterator>&  vit = fMap_it->second;
 
    G4KDNode* tmpNode = fMap_it->first;
 
    for(std::size_t i = 0 ; i < fSortOut.size() ; i++)
    {
    G4cout << "i = " << i << G4endl;
    G4cout << "vit[i] = " << *(vit[i]) << G4endl;
    if(*(vit[i]) != tmpNode)
    {
    G4cout << "!!!! Wrong iterator" << G4endl;
    abort();
    }
    }
 
    }
    */
 
   fIsSorted = false;
 }
 
 G4KDNode_Base* G4KDMap::PopOutMiddle(std::size_t dimension)
 {
   G4cout << "_____________" << G4endl;
   G4cout << "G4KDMap::PopOutMiddle ( "<< dimension << " )" << G4endl;
 
   if(!fIsSorted) Sort();
   G4KDNode_Base* output_node = fSortOut[dimension].PopOutMiddle();
 
   if(output_node == nullptr) return nullptr;
 
   G4cout << "output_node : " << output_node << G4endl;
   G4cout << "output_node : " << output_node->GetAxis() << G4endl;
 
   auto fMap_it
   = fMap.find(output_node);
 
 
    if(fMap_it == fMap.end())
    {
      G4cout << "fMap_it == fMap.end()" << G4endl;
      G4cout << "output_node = " << output_node << G4endl;
      return output_node;
    }
 
   std::vector<_deq_iterator>& vit = fMap_it->second;
 
   /*
    if(fMap_it->first != output_node)
    {
    G4cout << "fMap_it->first ! output_node"<< G4endl;
    G4cout << "fMap_it->first = " << fMap_it->first << G4endl;
    abort();
    }
    */
 
   for(std::size_t i = 0; i < fSortOut.size(); ++i)
   {
     if(i != dimension)
     {
       G4cout << "i = " << i << G4endl;
 
       /*
        // G4cout << "i = " << i << G4endl;
        // G4cout << "vit[i] = " << *(vit[i]) << G4endl;
        if(*(vit[i]) != output_node)
        {
        G4cout << "deleting wrong iterator" << G4endl;
        abort();
        }
        */
       fSortOut[i].Erase(vit[i]);
     }
   }
 
   fMap.erase(fMap_it);
 
   return output_node;
 }
 
 void G4KDMap::Sort()
 {
   for (auto & i : fSortOut)
   {
     i.Sort();
   }
 
   fIsSorted = true;
 }