ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4KDMap.cc
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file G4KDMap.cc
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 #include "G4KDMap.hh"
27 #include "globals.hh"
28 #include "G4KDNode.hh"
29 #include <algorithm>
30 
31 using namespace std;
32 
33 typedef std::deque<G4KDNode_Base*>::iterator _deq_iterator;
34 
36  G4KDNode_Base* const & rhs) //const
37 {
38  return (*lhs)[fDimension] < (*rhs)[fDimension];
39 }
40 
41 __1DSortOut::__1DSortOut(size_t dimension) :
42  fSortOutNDim(dimension)
43 {
44 }
45 
47  fContainer(right.fContainer), fSortOutNDim(right.fSortOutNDim)
48 {
49 }
50 
52 {
53  return fSortOutNDim.fDimension;
54 }
55 
56 G4KDNode_Base* __1DSortOut::GetMidle(size_t& main_middle)
57 {
58  size_t contSize = fContainer.size();
59  main_middle = (size_t) ceil(contSize / 2.); // ceil = round up
60  return fContainer[main_middle];
61 }
62 
64 {
65  return fContainer.insert(fContainer.end(), pos);
66 }
67 
69 {
70  size_t middle;
71  G4KDNode_Base* pos = GetMidle(middle);
72  _deq_iterator deq_pos = fContainer.begin() + middle;
73 
74  if(deq_pos == fContainer.end()) return 0; // this is a double check
75 
76  fContainer.erase(deq_pos);
77  return pos;
78 }
79 
81 {
82  sort(fContainer.begin(), fContainer.end(), fSortOutNDim);
83 }
84 
86 {
87  fContainer.erase(deq_pos);
88 }
89 
91 {
92  vector<_deq_iterator>& vit = fMap[pos];
93 
94  size_t maxSize = fSortOut.size();
95 
96  G4cout << "G4KDMap::Insert : " << maxSize << G4endl;
97 
98  vit.reserve(maxSize);
99 
100  for (size_t i = 0; i < fSortOut.size(); ++i)
101  {
102  vit[i] = fSortOut[i].Insert(pos);
103 
104 // if(*(vit[i]) != pos)
105 // {
106 // G4cout << "insert wrong iterator" << G4endl;
107 // abort();
108 // }
109  }
110  /*
111  std::map<G4KDNode*, std::vector<_deq_iterator> >::iterator fMap_it
112  = fMap.begin();
113 
114  for( ; fMap_it != fMap.end() ; fMap_it++)
115  {
116  std::vector<_deq_iterator>& vit = fMap_it->second;
117 
118  G4KDNode* tmpNode = fMap_it->first;
119 
120  for(size_t i = 0 ; i < fSortOut.size() ; i++)
121  {
122  G4cout << "i = " << i << G4endl;
123  G4cout << "vit[i] = " << *(vit[i]) << G4endl;
124  if(*(vit[i]) != tmpNode)
125  {
126  G4cout << "!!!! Wrong iterator" << G4endl;
127  abort();
128  }
129  }
130 
131  }
132  */
133 
134  fIsSorted = false;
135 }
136 
138 {
139  G4cout << "_____________" << G4endl;
140  G4cout << "G4KDMap::PopOutMiddle ( "<< dimension << " )" << G4endl;
141 
142  if(fIsSorted == false) Sort();
143  G4KDNode_Base* output_node = fSortOut[dimension].PopOutMiddle();
144 
145  if(output_node == 0) return 0;
146 
147  G4cout << "output_node : " << output_node << G4endl;
148  G4cout << "output_node : " << output_node->GetAxis() << G4endl;
149 
150  std::map<G4KDNode_Base*, std::vector<_deq_iterator> >::iterator fMap_it
151  = fMap.find(output_node);
152 
153 
154  if(fMap_it == fMap.end())
155  {
156  G4cout << "fMap_it == fMap.end()" << G4endl;
157  G4cout << "output_node = " << output_node << G4endl;
158  return output_node;
159  }
160 
161  std::vector<_deq_iterator>& vit = fMap_it->second;
162 
163  /*
164  if(fMap_it->first != output_node)
165  {
166  G4cout << "fMap_it->first ! output_node"<< G4endl;
167  G4cout << "fMap_it->first = " << fMap_it->first << G4endl;
168  abort();
169  }
170  */
171 
172  for(size_t i = 0; i < fSortOut.size(); i++)
173  {
174  if(i != dimension)
175  {
176  G4cout << "i = " << i << G4endl;
177 
178  /*
179  // G4cout << "i = " << i << G4endl;
180  // G4cout << "vit[i] = " << *(vit[i]) << G4endl;
181  if(*(vit[i]) != output_node)
182  {
183  G4cout << "deleting wrong iterator" << G4endl;
184  abort();
185  }
186  */
187  fSortOut[i].Erase(vit[i]);
188  }
189  }
190 
191  fMap.erase(fMap_it);
192 
193  return output_node;
194 }
195 
197 {
198  for (size_t i = 0; i < fSortOut.size(); ++i)
199  {
200  fSortOut[i].Sort();
201  }
202 
203  fIsSorted = true;
204 }