G4KDMap Class Reference

#include <G4KDMap.hh>

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 ()

Detailed Description

Definition at line 89 of file G4KDMap.hh.

Constructor & Destructor Documentation

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

Member Function Documentation

size_t G4KDMap::GetDimension ( )

inline

Definition at line 105 of file G4KDMap.hh.

  {
      return fSortOut.size();
  }

size_t G4KDMap::GetSize ( )

inline

Definition at line 110 of file G4KDMap.hh.

  {
      return fMap.size();
  }

Here is the caller graph for this function:

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:

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:

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

Here is the caller graph for this function:

---

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

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