G4KDMap Class Reference

#include <G4KDMap.hh>

Collaboration diagram for G4KDMap:

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

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

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);
//        }
    }

Here is the call graph for this function:

Member Function Documentation

GetDimension()

size_t G4KDMap::GetDimension ( )

inline

Definition at line 105 of file G4KDMap.hh.

    {
        return fSortOut.size();
    }

GetSize()

size_t G4KDMap::GetSize ( )

inline

Definition at line 110 of file G4KDMap.hh.

    {
        return fMap.size();
    }

Here is the caller graph for this function:

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

Here is the caller graph for this function:

PopOutMiddle()

G4KDNode_Base * G4KDMap::PopOutMiddle

(

size_t

dimension

)

Definition at line 138 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Sort()

void G4KDMap::Sort

(

)

Definition at line 197 of file G4KDMap.cc.

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

  fIsSorted = true;
}

Member Data Documentation

fIsSorted

bool G4KDMap::fIsSorted

private

Definition at line 116 of file G4KDMap.hh.

fMap

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

private

Definition at line 118 of file G4KDMap.hh.

fSortOut

std::vector<__1DSortOut> G4KDMap::fSortOut

private

Definition at line 117 of file G4KDMap.hh.

---

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

• G4KDMap.hh
• G4KDMap.cc