G4KDMap Class Reference

#include <G4KDMap.hh>

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

Private Attributes
bool	fIsSorted
std::map< G4KDNode_Base *, std::vector< std::deque< G4KDNode_Base * >::iterator > >	fMap
std::vector< __1DSortOut >	fSortOut

Detailed Description

Definition at line 89 of file G4KDMap.hh.

Constructor & Destructor Documentation

G4KDMap()

G4KDMap::G4KDMap ( size_t  dimensions )

inline

Definition at line 92 of file G4KDMap.hh.

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

References fIsSorted.

Member Function Documentation

GetDimension()

size_t G4KDMap::GetDimension ( )

inline

Definition at line 105 of file G4KDMap.hh.

  {
      return fSortOut.size();
  }

References fSortOut.

GetSize()

size_t G4KDMap::GetSize ( )

inline

Definition at line 110 of file G4KDMap.hh.

  {
      return fMap.size();
  }

References fMap.

Referenced by G4KDTree::Build().

Insert()

void G4KDMap::Insert

(

G4KDNode_Base *

pos

)

Definition at line 90 of file G4KDMap.cc.

{
  vector<_deq_iterator>& vit = fMap[pos];
 
  size_t maxSize = fSortOut.size();
 
  G4cout << "G4KDMap::Insert : " << maxSize << G4endl;
 
  vit.reserve(maxSize);
 
  for (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(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;
}

References fIsSorted, fMap, fSortOut, G4cout, G4endl, and pos.

Referenced by G4KDTree::__InsertMap().

PopOutMiddle()

G4KDNode_Base * G4KDMap::PopOutMiddle

(

size_t

dimension

)

Definition at line 137 of file G4KDMap.cc.

{
  G4cout << "_____________" << G4endl;
  G4cout << "G4KDMap::PopOutMiddle ( "<< dimension << " )" << G4endl;
 
  if(fIsSorted == false) Sort();
  G4KDNode_Base* output_node = fSortOut[dimension].PopOutMiddle();
 
  if(output_node == 0) return 0;
 
  G4cout << "output_node : " << output_node << G4endl;
  G4cout << "output_node : " << output_node->GetAxis() << G4endl;
 
  std::map<G4KDNode_Base*, std::vector<_deq_iterator> >::iterator 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(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;
}

References fIsSorted, fMap, fSortOut, G4cout, G4endl, G4KDNode_Base::GetAxis(), and Sort().

Referenced by G4KDTree::Build().

Sort()

void G4KDMap::Sort

(

)

Definition at line 196 of file G4KDMap.cc.

{
  for (size_t i = 0; i < fSortOut.size(); ++i)
  {
    fSortOut[i].Sort();
  }
 
  fIsSorted = true;
}

References fIsSorted, and fSortOut.

Referenced by PopOutMiddle().

Field Documentation

fIsSorted

bool G4KDMap::fIsSorted

private

Definition at line 116 of file G4KDMap.hh.

Referenced by G4KDMap(), Insert(), PopOutMiddle(), and Sort().

fMap

std::map<G4KDNode_Base*, std::vector<std::deque<G4KDNode_Base*>::iterator> > G4KDMap::fMap

private

Definition at line 118 of file G4KDMap.hh.

Referenced by GetSize(), Insert(), and PopOutMiddle().

fSortOut

std::vector<__1DSortOut> G4KDMap::fSortOut

private

Definition at line 117 of file G4KDMap.hh.

Referenced by GetDimension(), Insert(), PopOutMiddle(), and Sort().

---

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

• source/processes/electromagnetic/dna/management/include/G4KDMap.hh
• source/processes/electromagnetic/dna/management/src/G4KDMap.cc