G4KDMap Class Reference

#include <G4KDMap.hh>

Public Member Functions
	G4KDMap (std::size_t dimensions)
void	Insert (G4KDNode_Base *pos)
void	Sort ()
G4KDNode_Base *	PopOutMiddle (std::size_t dimension)
std::size_t	GetDimension ()
std::size_t	GetSize ()

Detailed Description

Definition at line 91 of file G4KDMap.hh.

Constructor & Destructor Documentation

G4KDMap()

G4KDMap::G4KDMap ( std::size_t dimensions )

inline

Definition at line 94 of file G4KDMap.hh.

                               : fSortOut(dimensions, __1DSortOut(dimensions))
  {
        fIsSorted = false;
//        for(std::size_t i = 0 ; i < dimensions ; ++i)
//        {
//            fSortOut[i] = new __1DSortOut(i);
//        }
  }

Member Function Documentation

GetDimension()

std::size_t G4KDMap::GetDimension ( )

inline

Definition at line 107 of file G4KDMap.hh.

  {
      return fSortOut.size();
  }

GetSize()

std::size_t G4KDMap::GetSize ( )

inline

Definition at line 112 of file G4KDMap.hh.

  {
      return fMap.size();
  }

Insert()

void G4KDMap::Insert

(

G4KDNode_Base *

pos

)

Definition at line 88 of file G4KDMap.cc.

{
  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;
}

PopOutMiddle()

G4KDNode_Base * G4KDMap::PopOutMiddle

(

std::size_t

dimension

)

Definition at line 135 of file G4KDMap.cc.

{
  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;
}

Sort()

void G4KDMap::Sort

(

)

Definition at line 194 of file G4KDMap.cc.

{
  for (auto & i : fSortOut)
  {
    i.Sort();
  }
 
  fIsSorted = true;
}

Referenced by PopOutMiddle().

---

The documentation for this class was generated from the following files:

• G4KDMap.hh
• G4KDMap.cc