Geant4  v4-10.4-release
 모두 클래스 네임스페이스들 파일들 함수 변수 타입정의 열거형 타입 열거형 멤버 Friends 매크로 그룹들 페이지들
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 }
sortOutNDim fSortOutNDim
Definition: G4KDMap.hh:86
G4KDNode_Base * GetMidle(size_t &)
Definition: G4KDMap.cc:56
int GetDimension()
Definition: G4KDMap.cc:51
static const G4double pos
std::deque< G4KDNode_Base * >::iterator Insert(G4KDNode_Base *)
Definition: G4KDMap.cc:63
#define G4endl
Definition: G4ios.hh:61
void Sort()
Definition: G4KDMap.cc:80
G4KDNode_Base * PopOutMiddle(size_t dimension)
Definition: G4KDMap.cc:137
G4KDNode_Base * PopOutMiddle()
Definition: G4KDMap.cc:68
void Erase(std::deque< G4KDNode_Base * >::iterator &)
Definition: G4KDMap.cc:85
int GetAxis() const
Definition: G4KDNode.hh:80
std::map< G4KDNode_Base *, std::vector< std::deque< G4KDNode_Base * >::iterator > > fMap
Definition: G4KDMap.hh:118
bool fIsSorted
Definition: G4KDMap.hh:116
void Sort()
Definition: G4KDMap.cc:196
std::deque< G4KDNode_Base * > fContainer
Definition: G4KDMap.hh:85
__1DSortOut(size_t dimension)
Definition: G4KDMap.cc:41
std::vector< __1DSortOut > fSortOut
Definition: G4KDMap.hh:117
G4GLOB_DLL std::ostream G4cout
void Insert(G4KDNode_Base *pos)
Definition: G4KDMap.cc:90
std::deque< G4KDNode_Base * >::iterator _deq_iterator
Definition: G4KDMap.cc:33
bool operator()(G4KDNode_Base *const &lhs, G4KDNode_Base *const &rhs)
Definition: G4KDMap.cc:35