Removing file based inter-detector communications (Yu.Belikov)
[u/mrichter/AliRoot.git] / RALICE / AliEvent.cxx
CommitLineData
d16062ac 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
1c01b4f8 16// $Id: AliEvent.cxx,v 1.13 2003/08/29 09:05:11 nick Exp $
d16062ac 17
18///////////////////////////////////////////////////////////////////////////
19// Class AliEvent
20// Creation and investigation of an Alice physics event.
7849a8ab 21// An AliEvent can be constructed by adding AliTracks, Alivertices, AliJets
1c01b4f8 22// and/or devices like AliCalorimeters.
23// All objects which are derived from TObject can be regarded as a device.
d16062ac 24//
25// The basic functionality of AliEvent is identical to the one of AliVertex.
35044448 26// So, an AliEvent may be used as the primary vertex with some additional
27// functionality compared to AliVertex.
d16062ac 28//
7849a8ab 29// To provide maximal flexibility to the user, the two modes of track/jet/vertex
30// storage as described in AliJet and AliVertex can be used.
1c01b4f8 31// In addition an identical structure is provided for the storage of devices like
32// AliCalorimeter objects, which can be selected by means of the memberfunction
33// SetDevCopy().
34//
35// a) SetDevCopy(0) (which is the default).
36// Only the pointers of the 'added' devices are stored.
37// This mode is typically used by making studies based on a fixed set
38// of devices which stays under user control or is kept on an external
7849a8ab 39// file/tree.
40// In this way the AliEvent just represents a 'logical structure' for the
41// physics analysis.
35044448 42//
43// Note :
1c01b4f8 44// Modifications made to the original devices also affect the device
7849a8ab 45// objects which are stored in the AliEvent.
35044448 46//
1c01b4f8 47// b) SetDevCopy(1).
48// Of every 'added' device a private copy will be made of which the pointer
7849a8ab 49// will be stored.
50// In this way the AliEvent represents an entity on its own and modifications
51// made to the original calorimeters do not affect the AliCalorimeter objects
52// which are stored in the AliEvent.
1c01b4f8 53// This mode will allow 'adding' many different devices into an AliEvent by
54// creating only one device instance in the main programme and using the
55// Reset() and parameter setting memberfunctions of the object representing the device.
56//
57// Note :
58// The copy is made using the Clone() memberfunction.
59// All devices (i.e. classes derived from TObject) have the default TObject::Clone()
60// memberfunction.
61// However, devices generally contain an internal (signal) data structure
62// which may include pointers to other objects. Therefore it is recommended to provide
63// for all devices a specific copy constructor and override the default Clone()
64// memberfunction using this copy constructor.
65// An example for this may be seen from AliCalorimeter.
7849a8ab 66//
8e8e6c7f 67// See also the documentation provided for the memberfunction SetOwner().
68//
7849a8ab 69// Coding example to make an event consisting of a primary vertex,
70// 2 secondary vertices and a calorimeter.
d16062ac 71// --------------------------------------------------------------
7849a8ab 72// vp contains the tracks 1,2,3 and 4 (primary vertex)
73// v1 contains the tracks 5,6 and 7 (sec. vertex)
74// v2 contains the jets 1 and 2 (sec. vertex)
75//
7849a8ab 76// AliEvent evt;
77//
78// Specify the event object as the repository of all objects
79// for the event building and physics analysis.
80//
1c01b4f8 81// evt.SetDevCopy(1);
7849a8ab 82// evt.SetTrackCopy(1);
83//
84// Fill the event structure with the basic objects
85//
35044448 86// AliCalorimeter emcal;
87// ...
88// ... // code to fill the calorimeter data
89// ...
90//
1c01b4f8 91// evt.AddDevice(emcal);
7849a8ab 92//
35044448 93// AliTrack* tx=new AliTrack();
7849a8ab 94// for (Int_t i=0; i<10; i++)
95// {
d16062ac 96// ...
97// ... // code to fill the track data
98// ...
7849a8ab 99// evt.AddTrack(tx);
100// tx->Reset();
101// }
102//
35044448 103// if (tx)
104// {
105// delete tx;
106// tx=0;
107// }
108//
7849a8ab 109// Build the event structure (vertices, jets, ...) for physics analysis
110// based on the basic objects from the event repository.
d16062ac 111//
112// AliJet j1,j2;
7849a8ab 113// for (Int_t i=0; i<evt.GetNtracks(); i++)
114// {
115// tx=evt.GetTrack(i);
d16062ac 116// ...
117// ... // code to fill the jet data
118// ...
7849a8ab 119// }
d16062ac 120//
7849a8ab 121// AliVertex vp;
35044448 122// tx=evt.GetTrack(1);
7849a8ab 123// vp.AddTrack(tx);
35044448 124// tx=evt.GetTrack(2);
7849a8ab 125// vp.AddTrack(tx);
35044448 126// tx=evt.GetTrack(3);
7849a8ab 127// vp.AddTrack(tx);
35044448 128// tx=evt.GetTrack(4);
7849a8ab 129// vp.AddTrack(tx);
d16062ac 130//
7849a8ab 131// Float_t rp[3]={2.4,0.1,-8.5};
132// vp.SetPosition(rp,"car");
d16062ac 133//
7849a8ab 134// AliVertex v1;
35044448 135// tx=evt.GetTrack(5);
7849a8ab 136// v1.AddTrack(tx);
35044448 137// tx=evt.GetTrack(6);
7849a8ab 138// v1.AddTrack(tx);
35044448 139// tx=evt.GetTrack(7);
7849a8ab 140// v1.AddTrack(tx);
d16062ac 141//
142// Float_t r1[3]={1.6,-3.2,5.7};
143// v1.SetPosition(r1,"car");
144//
d16062ac 145//
7849a8ab 146// AliVertex v2;
147// v2.SetJetCopy(1);
d16062ac 148// v2.AddJet(j1);
149// v2.AddJet(j2);
150//
151// Float_t r2[3]={6.2,4.8,1.3};
152// v2.SetPosition(r2,"car");
153//
7849a8ab 154// Specify the vertices v1 and v2 as secondary vertices of the primary
155//
156// vp.SetVertexCopy(1);
157// vp.AddVertex(v1);
158// vp.AddVertex(v2);
159//
160// Enter the physics structures into the event
161// evt.SetVertexCopy(1);
162// evt.AddVertex(vp,0);
163//
164// The jets j1 and j2 are already available via sec. vertex v2,
165// but can be made available also from the event itself if desired.
166// AliJet* jx;
167// jx=v2.GetJet(1);
168// evt.AddJet(jx,0);
169// jx=v2.GetJet(2);
170// evt.AddJet(jx,0);
171//
84bb7c66 172// evt.Data("sph");
d16062ac 173// v1.ListAll();
174// v2.List("cyl");
175//
176// Float_t etot=evt.GetEnergy();
177// Ali3Vector ptot=evt.Get3Momentum();
178// Float_t loc[3];
179// evt.GetPosition(loc,"sph");
180// AliPosition r=v1.GetPosition();
84bb7c66 181// r.Data();
d16062ac 182// Int_t nt=v2.GetNtracks();
183// AliTrack* tv=v2.GetTrack(1); // Access track number 1 of Vertex v2
184//
d16062ac 185// evt.List();
186//
187// Int_t nv=evt.GetNvtx();
7849a8ab 188// AliVertex* vx=evt.GetVertex(1); // Access primary vertex
d16062ac 189// Float_t e=vx->GetEnergy();
190//
191// Float_t M=evt.GetInvmass();
192//
193// Reconstruct the event from scratch
194//
195// evt.Reset();
196// evt.SetNvmax(25); // Increase initial no. of sec. vertices
7849a8ab 197// ...
198// ... // code to create tracks etc...
199// ...
d16062ac 200//
201// Note : All quantities are in GeV, GeV/c or GeV/c**2
202//
203//--- Author: Nick van Eijndhoven 27-may-2001 UU-SAP Utrecht
1c01b4f8 204//- Modified: NvE $Date: 2003/08/29 09:05:11 $ UU-SAP Utrecht
d16062ac 205///////////////////////////////////////////////////////////////////////////
206
207#include "AliEvent.h"
c72198f1 208#include "Riostream.h"
d16062ac 209
210ClassImp(AliEvent) // Class implementation to enable ROOT I/O
211
c72198f1 212AliEvent::AliEvent() : AliVertex()
d16062ac 213{
214// Default constructor.
215// All variables initialised to default values.
216 fDaytime.Set();
217 fRun=0;
218 fEvent=0;
4575fcea 219 fAproj=0;
220 fZproj=0;
221 fPnucProj=0;
da17f667 222 fIdProj=0;
4575fcea 223 fAtarg=0;
224 fZtarg=0;
225 fPnucTarg=0;
da17f667 226 fIdTarg=0;
1c01b4f8 227 fDevices=0;
228 fDevCopy=0;
d16062ac 229}
230///////////////////////////////////////////////////////////////////////////
c72198f1 231AliEvent::AliEvent(Int_t n) : AliVertex(n)
d16062ac 232{
233// Create an event to hold initially a maximum of n tracks
234// All variables initialised to default values
c72198f1 235 if (n<=0)
236 {
237 cout << " *** This AliVertex initialisation was invoked via the AliEvent ctor." << endl;
238 }
d16062ac 239 fDaytime.Set();
240 fRun=0;
241 fEvent=0;
4575fcea 242 fAproj=0;
243 fZproj=0;
244 fPnucProj=0;
da17f667 245 fIdProj=0;
4575fcea 246 fAtarg=0;
247 fZtarg=0;
248 fPnucTarg=0;
da17f667 249 fIdTarg=0;
1c01b4f8 250 fDevices=0;
251 fDevCopy=0;
d16062ac 252}
253///////////////////////////////////////////////////////////////////////////
254AliEvent::~AliEvent()
255{
256// Default destructor
1c01b4f8 257 if (fDevices)
7849a8ab 258 {
1c01b4f8 259 delete fDevices;
260 fDevices=0;
7849a8ab 261 }
d16062ac 262}
263///////////////////////////////////////////////////////////////////////////
c72198f1 264AliEvent::AliEvent(AliEvent& evt) : AliVertex(evt)
265{
266// Copy constructor.
267 fDaytime=evt.fDaytime;
268 fRun=evt.fRun;
269 fEvent=evt.fEvent;
270 fAproj=evt.fAproj;
271 fZproj=evt.fZproj;
272 fPnucProj=evt.fPnucProj;
273 fIdProj=evt.fIdProj;
274 fAtarg=evt.fAtarg;
275 fZtarg=evt.fZtarg;
276 fPnucTarg=evt.fPnucTarg;
277 fIdTarg=evt.fIdTarg;
1c01b4f8 278 fDevCopy=evt.fDevCopy;
c72198f1 279
1c01b4f8 280 fDevices=0;
281 Int_t ndevs=evt.GetNdevices();
282 if (ndevs)
c72198f1 283 {
1c01b4f8 284 fDevices=new TObjArray(ndevs);
285 if (fDevCopy) fDevices->SetOwner();
286 for (Int_t i=1; i<=ndevs; i++)
c72198f1 287 {
1c01b4f8 288 TObject* dev=evt.GetDevice(i);
289 if (dev)
c72198f1 290 {
1c01b4f8 291 if (fDevCopy)
c72198f1 292 {
1c01b4f8 293 fDevices->Add(dev->Clone());
c72198f1 294 }
295 else
296 {
1c01b4f8 297 fDevices->Add(dev);
c72198f1 298 }
299 }
300 }
301 }
302}
303///////////////////////////////////////////////////////////////////////////
d16062ac 304void AliEvent::Reset()
305{
306// Reset all variables to default values
307// The max. number of tracks is set to the initial value again
308// The max. number of vertices is set to the default value again
8e8e6c7f 309// Note : The CalCopy mode is maintained as it was set by the user before.
c72198f1 310
311 AliVertex::Reset();
312
d16062ac 313 fDaytime.Set();
314 fRun=0;
315 fEvent=0;
4575fcea 316 fAproj=0;
317 fZproj=0;
318 fPnucProj=0;
da17f667 319 fIdProj=0;
4575fcea 320 fAtarg=0;
321 fZtarg=0;
322 fPnucTarg=0;
da17f667 323 fIdTarg=0;
d16062ac 324
1c01b4f8 325 if (fDevices)
7849a8ab 326 {
1c01b4f8 327 delete fDevices;
328 fDevices=0;
7849a8ab 329 }
d16062ac 330}
331///////////////////////////////////////////////////////////////////////////
8e8e6c7f 332void AliEvent::SetOwner(Bool_t own)
333{
334// Set ownership of all added objects.
335// The default parameter is own=kTRUE.
336//
337// Invokation of this memberfunction also sets all the copy modes
338// (e.g. TrackCopy & co.) according to the value of own.
339//
340// This function (with own=kTRUE) is particularly useful when reading data
341// from a tree/file, since Reset() will then actually remove all the
342// added objects from memory irrespective of the copy mode settings
343// during the tree/file creation process. In this way it provides a nice way
344// of preventing possible memory leaks in the reading/analysis process.
345//
346// In addition this memberfunction can also be used as a shortcut to set all
347// copy modes in one go during a tree/file creation process.
348// However, in this case the user has to take care to only set/change the
349// ownership (and copy mode) for empty objects (e.g. newly created objects
350// or after invokation of the Reset() memberfunction) otherwise it will
351// very likely result in inconsistent destructor behaviour.
352
353 Int_t mode=1;
354 if (!own) mode=0;
1c01b4f8 355 if (fDevices) fDevices->SetOwner(own);
356 fDevCopy=mode;
8e8e6c7f 357
358 AliVertex::SetOwner(own);
359}
360///////////////////////////////////////////////////////////////////////////
d16062ac 361void AliEvent::SetDayTime(TDatime& stamp)
362{
363// Set the date and time stamp for this event
364 fDaytime=stamp;
365}
366///////////////////////////////////////////////////////////////////////////
367void AliEvent::SetRunNumber(Int_t run)
368{
369// Set the run number for this event
370 fRun=run;
371}
372///////////////////////////////////////////////////////////////////////////
373void AliEvent::SetEventNumber(Int_t evt)
374{
375// Set the event number for this event
376 fEvent=evt;
377}
378///////////////////////////////////////////////////////////////////////////
379TDatime AliEvent::GetDayTime()
380{
381// Provide the date and time stamp for this event
382 return fDaytime;
383}
384///////////////////////////////////////////////////////////////////////////
385Int_t AliEvent::GetRunNumber()
386{
387// Provide the run number for this event
388 return fRun;
389}
390///////////////////////////////////////////////////////////////////////////
391Int_t AliEvent::GetEventNumber()
392{
393// Provide the event number for this event
394 return fEvent;
395}
396///////////////////////////////////////////////////////////////////////////
da17f667 397void AliEvent::SetProjectile(Int_t a,Int_t z,Double_t pnuc,Int_t id)
4575fcea 398{
da17f667 399// Set the projectile A, Z, momentum per nucleon and user defined particle ID.
400// By default the particle ID is set to zero.
4575fcea 401 fAproj=a;
402 fZproj=z;
403 fPnucProj=pnuc;
da17f667 404 fIdProj=id;
4575fcea 405}
406///////////////////////////////////////////////////////////////////////////
407Int_t AliEvent::GetProjectileA()
408{
409// Provide the projectile A value.
410 return fAproj;
411}
412///////////////////////////////////////////////////////////////////////////
413Int_t AliEvent::GetProjectileZ()
414{
415// Provide the projectile Z value.
416 return fZproj;
417}
418///////////////////////////////////////////////////////////////////////////
419Double_t AliEvent::GetProjectilePnuc()
420{
421// Provide the projectile momentum value per nucleon.
422 return fPnucProj;
423}
424///////////////////////////////////////////////////////////////////////////
da17f667 425Int_t AliEvent::GetProjectileId()
4575fcea 426{
da17f667 427// Provide the user defined particle ID of the projectile.
428 return fIdProj;
429}
430///////////////////////////////////////////////////////////////////////////
431void AliEvent::SetTarget(Int_t a,Int_t z,Double_t pnuc,Int_t id)
432{
433// Set the target A, Z, momentum per nucleon and user defined particle ID.
434// By default the particle ID is set to zero.
4575fcea 435 fAtarg=a;
436 fZtarg=z;
437 fPnucTarg=pnuc;
da17f667 438 fIdTarg=id;
4575fcea 439}
440///////////////////////////////////////////////////////////////////////////
441Int_t AliEvent::GetTargetA()
442{
443// Provide the target A value.
444 return fAtarg;
445}
446///////////////////////////////////////////////////////////////////////////
447Int_t AliEvent::GetTargetZ()
448{
449// Provide the target Z value.
450 return fZtarg;
451}
452///////////////////////////////////////////////////////////////////////////
453Double_t AliEvent::GetTargetPnuc()
454{
455// Provide the target momentum value per nucleon.
456 return fPnucTarg;
457}
458///////////////////////////////////////////////////////////////////////////
da17f667 459Int_t AliEvent::GetTargetId()
460{
461// Provide the user defined particle ID of the target.
462 return fIdTarg;
463}
464///////////////////////////////////////////////////////////////////////////
84bb7c66 465void AliEvent::HeaderData()
d16062ac 466{
467// Provide event header information
1c01b4f8 468 cout << " *" << ClassName() << "::Data* Run : " << fRun << " Event : " << fEvent
1ce8a857 469 << " Date : " << fDaytime.AsString() << endl;
d16062ac 470
1c01b4f8 471 ShowDevices();
d16062ac 472}
473///////////////////////////////////////////////////////////////////////////
84bb7c66 474void AliEvent::Data(TString f)
d16062ac 475{
476// Provide event information within the coordinate frame f
84bb7c66 477 HeaderData();
478 AliVertex::Data(f);
d16062ac 479}
480///////////////////////////////////////////////////////////////////////////
1c01b4f8 481Int_t AliEvent::GetNdevices()
7849a8ab 482{
1c01b4f8 483// Provide the number of stored devices
484 Int_t ndevs=0;
485 if (fDevices) ndevs=fDevices->GetEntries();
486 return ndevs;
7849a8ab 487}
488///////////////////////////////////////////////////////////////////////////
1c01b4f8 489void AliEvent::AddDevice(TObject& d)
7849a8ab 490{
1c01b4f8 491// Add a device to the event.
492//
493// Note :
494// In case a private copy is made, this is performed via the Clone() memberfunction.
495// All devices (i.e. classes derived from TObject) have the default TObject::Clone()
496// memberfunction.
497// However, devices generally contain an internal (signal) data structure
498// which may include pointers to other objects. Therefore it is recommended to provide
499// for all devices a specific copy constructor and override the default Clone()
500// memberfunction using this copy constructor.
501// An example for this may be seen from AliCalorimeter.
502
503 if (!fDevices)
6516b62d 504 {
1c01b4f8 505 fDevices=new TObjArray();
506 if (fDevCopy) fDevices->SetOwner();
6516b62d 507 }
7849a8ab 508
1c01b4f8 509 // Add the device to this event
510 if (fDevCopy)
7849a8ab 511 {
1c01b4f8 512 fDevices->Add(d.Clone());
7849a8ab 513 }
514 else
515 {
1c01b4f8 516 fDevices->Add(&d);
7849a8ab 517 }
518}
519///////////////////////////////////////////////////////////////////////////
1c01b4f8 520void AliEvent::SetDevCopy(Int_t j)
7849a8ab 521{
1c01b4f8 522// (De)activate the creation of private copies of the added devices.
523// j=0 ==> No private copies are made; pointers of original devices are stored.
524// j=1 ==> Private copies of the devices are made and these pointers are stored.
525//
526//
527// Notes :
528// In case a private copy is made, this is performed via the Clone() memberfunction.
529// All devices (i.e. classes derived from TObject) have the default TObject::Clone()
530// memberfunction.
531// However, devices generally contain an internal (signal) data structure
532// which may include pointers to other objects. Therefore it is recommended to provide
533// for all devices a specific copy constructor and override the default Clone()
534// memberfunction using this copy constructor.
535// An example for this may be seen from AliCalorimeter.
536//
537// Once the storage contains pointer(s) to device(s) one cannot
538// change the DevCopy mode anymore.
539// To change the DevCopy mode for an existing AliEvent containing
540// devices one first has to invoke Reset().
541
542 if (!fDevices)
7849a8ab 543 {
544 if (j==0 || j==1)
545 {
1c01b4f8 546 fDevCopy=j;
7849a8ab 547 }
548 else
549 {
1c01b4f8 550 cout << " *" << ClassName() << "::SetDevCopy* Invalid argument : " << j << endl;
7849a8ab 551 }
552 }
553 else
554 {
1c01b4f8 555 cout << " *" << ClassName() << "::SetDevCopy* Storage already contained devices."
556 << " ==> DevCopy mode not changed." << endl;
7849a8ab 557 }
558}
559///////////////////////////////////////////////////////////////////////////
1c01b4f8 560Int_t AliEvent::GetDevCopy()
7849a8ab 561{
1c01b4f8 562// Provide value of the DevCopy mode.
563// 0 ==> No private copies are made; pointers of original devices are stored.
564// 1 ==> Private copies of the devices are made and these pointers are stored.
565//
566// Note :
567// In case a private copy is made, this is performed via the Clone() memberfunction.
568// All devices (i.e. classes derived from TObject) have the default TObject::Clone()
569// memberfunction.
570// However, devices generally contain an internal (signal) data structure
571// which may include pointers to other objects. Therefore it is recommended to provide
572// for all devices a specific copy constructor and override the default Clone()
573// memberfunction using this copy constructor.
574// An example for this may be seen from AliCalorimeter.
575
576 return fDevCopy;
7849a8ab 577}
578///////////////////////////////////////////////////////////////////////////
1c01b4f8 579TObject* AliEvent::GetDevice(Int_t i)
7849a8ab 580{
1c01b4f8 581// Return the i-th device of this event.
582// The first device corresponds to i=1.
583
584 if (!fDevices)
7849a8ab 585 {
1c01b4f8 586 cout << " *AliEvent::GetDevice* No devices present." << endl;
7849a8ab 587 return 0;
588 }
589 else
590 {
1c01b4f8 591 Int_t ndevs=GetNdevices();
592 if (i<=0 || i>ndevs)
7849a8ab 593 {
1c01b4f8 594 cout << " *" << ClassName() << "::GetDevice* Invalid argument i : " << i
595 << " ndevs = " << ndevs << endl;
7849a8ab 596 return 0;
597 }
598 else
599 {
1c01b4f8 600 return fDevices->At(i-1);
7849a8ab 601 }
602 }
603}
604///////////////////////////////////////////////////////////////////////////
1c01b4f8 605TObject* AliEvent::GetDevice(TString name)
7849a8ab 606{
1c01b4f8 607// Return the device with name tag "name"
608 if (!fDevices)
7849a8ab 609 {
1c01b4f8 610 cout << " *" << ClassName() << "::GetDevice* No devices present." << endl;
7849a8ab 611 return 0;
612 }
613 else
614 {
7849a8ab 615 TString s;
1c01b4f8 616 Int_t ndevs=GetNdevices();
617 for (Int_t i=0; i<ndevs; i++)
7849a8ab 618 {
1c01b4f8 619 TObject* dev=fDevices->At(i);
620 if (dev)
35044448 621 {
1c01b4f8 622 s=dev->GetName();
623 if (s == name) return dev;
35044448 624 }
7849a8ab 625 }
626
627 return 0; // No matching name found
628 }
629}
630///////////////////////////////////////////////////////////////////////////
1c01b4f8 631void AliEvent::ShowDevices()
1ce8a857 632{
1c01b4f8 633// Provide an overview of the available devices.
634 Int_t ndevs=GetNdevices();
635 if (ndevs)
1ce8a857 636 {
1c01b4f8 637 cout << " The following " << ndevs << " devices are available :" << endl;
638 for (Int_t i=1; i<=ndevs; i++)
1ce8a857 639 {
1c01b4f8 640 TObject* dev=GetDevice(i);
641 if (dev)
642 {
643 cout << " Device number : " << i
644 << " Class : " << dev->ClassName()
645 << " Name : " << dev->GetName() << endl;
646 }
1ce8a857 647 }
648 }
649 else
650 {
1c01b4f8 651 cout << " No devices present for this event." << endl;
1ce8a857 652 }
653}
654///////////////////////////////////////////////////////////////////////////
d16062ac 655