Line data Source code
1 : /**************************************************************************
2 : * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 : * *
4 : * Author: The ALICE Off-line Project. *
5 : * Contributors are mentioned in the code where appropriate. *
6 : * *
7 : * Permission to use, copy, modify and distribute this software and its *
8 : * documentation strictly for non-commercial purposes is hereby granted *
9 : * without fee, provided that the above copyright notice appears in all *
10 : * copies and that both the copyright notice and this permission notice *
11 : * appear in the supporting documentation. The authors make no claims *
12 : * about the suitability of this software for any purpose. It is *
13 : * provided "as is" without express or implied warranty. *
14 : **************************************************************************/
15 :
16 : // $Id$
17 : // $MpId: AliMpSlatPadIterator.cxx,v 1.6 2006/05/24 13:58:50 ivana Exp $
18 :
19 : #include "AliMpSlatPadIterator.h"
20 :
21 : #include "AliLog.h"
22 : #include "AliMpArea.h"
23 : #include "AliMpPCB.h"
24 : #include "AliMpSlat.h"
25 : #include "AliMpPCBPadIterator.h"
26 :
27 :
28 : //-----------------------------------------------------------------------------
29 : /// \class AliMpSlatPadIterator
30 : ///
31 : /// Implementation of AliMpVPadIterator for slats.
32 : ///
33 : /// This class first split the input area (upon which to iterate)
34 : /// into a set of areas of constant pad size.
35 : /// Then each of those areas is iterated over, using
36 : /// AliMpSlatZonePadIterator objects.
37 : ///
38 : /// \author L. Aphecetche
39 : //-----------------------------------------------------------------------------
40 :
41 : /// \cond CLASSIMP
42 18 : ClassImp(AliMpSlatPadIterator)
43 : /// \endcond
44 :
45 : //_____________________________________________________________________________
46 : AliMpSlatPadIterator::AliMpSlatPadIterator()
47 0 : : AliMpVPadIterator(),
48 0 : fkSlat(0),
49 0 : fDelegates(),
50 0 : fCurrentDelegate(0),
51 0 : fCurrentDelegateIndex(0)
52 0 : {
53 : ///
54 : /// Empty (default) ctor.
55 : ///
56 0 : }
57 :
58 : //_____________________________________________________________________________
59 : AliMpSlatPadIterator::AliMpSlatPadIterator(const AliMpSlat* slat,
60 : const AliMpArea& area)
61 102 : : AliMpVPadIterator(),
62 102 : fkSlat(slat),
63 102 : fDelegates(),
64 102 : fCurrentDelegate(0),
65 102 : fCurrentDelegateIndex(0)
66 510 : {
67 : ///
68 : /// Normal ctor.
69 : /// The iteration will occur on the given slat over the specified area.
70 : ///
71 510 : AliDebug(1,Form("this=%p ctor area=(%e,%e,%e,%e)",this,
72 : area.LeftBorder(),area.DownBorder(),
73 : area.RightBorder(),area.UpBorder()));
74 204 : if (!Prepare(area))
75 : {
76 0 : AliError("Iterator invalidated by improper initialization (e.g. incorrect area given ?)");
77 : }
78 102 : fDelegates.SetOwner(kTRUE);
79 204 : }
80 :
81 : //_____________________________________________________________________________
82 : AliMpSlatPadIterator::~AliMpSlatPadIterator()
83 612 : {
84 : ///
85 : /// Dtor.
86 : ///
87 510 : AliDebug(1,Form("this=%p dtor",this));
88 102 : Invalidate();
89 306 : }
90 :
91 : //_____________________________________________________________________________
92 : AliMpArea
93 : AliMpSlatPadIterator::Intersect(const AliMpArea& a, const AliMpArea& b) const
94 : {
95 : ///
96 : /// Returns the common part of a and b.
97 : ///
98 2040 : AliDebug(4,Form("a=(%7.2f,%7.2f;%7.2f,%7.2f) b=(%7.2f,%7.2f;%7.2f,%7.2f)",
99 : a.LeftBorder(),a.DownBorder(),a.RightBorder(),a.UpBorder(),
100 : b.LeftBorder(),b.DownBorder(),b.RightBorder(),b.UpBorder()));
101 :
102 510 : Double_t xmin = TMath::Max(a.LeftBorder(),b.LeftBorder());
103 510 : Double_t xmax = TMath::Min(a.RightBorder(),b.RightBorder());
104 510 : Double_t ymin = TMath::Max(a.DownBorder(),b.DownBorder());
105 510 : Double_t ymax = TMath::Min(a.UpBorder(),b.UpBorder());
106 1020 : AliMpArea c( (xmin+xmax)/2.0, (ymin+ymax)/2.0 ,
107 510 : (xmax-xmin)/2.0, (ymax-ymin)/2.0 );
108 :
109 2550 : AliDebug(4,Form("a intersect b = (%7.2f,%7.2f;%7.2f,%7.2f)",
110 : c.LeftBorder(),c.DownBorder(),c.RightBorder(),c.UpBorder()));
111 : return c;
112 1020 : }
113 :
114 : //_____________________________________________________________________________
115 : Bool_t
116 : AliMpSlatPadIterator::Prepare(const AliMpArea& area)
117 : {
118 : ///
119 : /// Split area into smaller area intersecting pcbs,
120 : /// and allocate the corresponding delegate iterators.
121 :
122 1326 : for ( Int_t i = 0; i < fkSlat->GetSize(); ++i )
123 : {
124 510 : const AliMpPCB* pcb = fkSlat->GetPCB(i);
125 510 : AliMpArea pcbArea(pcb->Area());
126 510 : AliMpArea zone = Intersect(pcbArea,area);
127 2550 : AliDebug(3,Form("i=%2d zone is %7.2f,%7.2f->%7.2f,%7.2f %d",i,
128 : zone.LeftBorder(),zone.DownBorder(),
129 : zone.RightBorder(),zone.UpBorder(),
130 : zone.IsValid()));
131 510 : if ( zone.IsValid() )
132 : {
133 330 : fDelegates.AddLast(new AliMpPCBPadIterator(fkSlat,zone));
134 : }
135 510 : }
136 306 : AliDebug(3,Form("Number of delegates = %d",fDelegates.GetEntries()));
137 : // StdoutToAliDebug(3,fDelegates.Print(););
138 102 : return fDelegates.GetLast()>=0;
139 0 : }
140 :
141 : //_____________________________________________________________________________
142 : AliMpPad
143 : AliMpSlatPadIterator::CurrentItem() const
144 : {
145 : ///
146 : /// Returns the current pad of the iteration.
147 : ///
148 2762 : if ( fCurrentDelegate )
149 : {
150 1381 : return fCurrentDelegate->CurrentItem();
151 : }
152 : else
153 : {
154 0 : return AliMpPad::Invalid();
155 : }
156 1381 : }
157 :
158 : //_____________________________________________________________________________
159 : void
160 : AliMpSlatPadIterator::First()
161 : {
162 : ///
163 : /// (Re)starts the iteration.
164 : ///
165 204 : if ( fDelegates.GetLast() < 0 )
166 : {
167 0 : AliError("Iterator is not valid, as it gets no delegates at all !");
168 0 : }
169 : else
170 : {
171 102 : fCurrentDelegateIndex = 0;
172 102 : fCurrentDelegate = static_cast<AliMpVPadIterator*>(fDelegates.At(0));
173 102 : fCurrentDelegate->First();
174 : }
175 102 : }
176 :
177 : //_____________________________________________________________________________
178 : void
179 : AliMpSlatPadIterator::Invalidate()
180 : {
181 : ///
182 : /// Make the iterator invalid.
183 : ///
184 204 : fDelegates.Delete();
185 102 : fCurrentDelegate = 0;
186 102 : fCurrentDelegateIndex = 0;
187 102 : }
188 :
189 : //_____________________________________________________________________________
190 : Bool_t
191 : AliMpSlatPadIterator::IsDone() const
192 : {
193 : ///
194 : /// Returns whether the iteration is ended or not.
195 : ///
196 8898 : return ( !fCurrentDelegate ||
197 2966 : ( fCurrentDelegateIndex > fDelegates.GetLast() &&
198 102 : fCurrentDelegate->IsDone() ) );
199 : }
200 :
201 : //_____________________________________________________________________________
202 : void
203 : AliMpSlatPadIterator::Next()
204 : {
205 : ///
206 : /// Next step of the iteration.
207 : ///
208 2762 : if (IsDone()) return;
209 :
210 1381 : fCurrentDelegate->Next();
211 :
212 1381 : if ( fCurrentDelegate->IsDone() )
213 : {
214 330 : AliDebug(3,"Moving to next delegate");
215 110 : ++fCurrentDelegateIndex;
216 110 : if ( fCurrentDelegateIndex <= fDelegates.GetLast() )
217 : {
218 8 : fCurrentDelegate = static_cast<AliMpVPadIterator*>(fDelegates.At(fCurrentDelegateIndex));
219 8 : fCurrentDelegate->First();
220 8 : }
221 : }
222 1381 : }
|
