[u/mrichter/AliRoot.git] / FMD / AliFMDGeometry.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/
/* $Id$ */
/** @file    AliFMDGeometry.cxx
    @author  Christian Holm Christensen <cholm@nbi.dk>
    @date    Mon Mar 27 12:40:37 2006
    @brief   Geometry mananger for the FMD
*/
//____________________________________________________________________
//                                                                          
// Forward Multiplicity Detector based on Silicon wafers. 
//
// This class is a singleton that handles the geometry parameters of
// the FMD detectors.  
//                                                       
// The actual code is done by various separate classes.   Below is
// diagram showing the relationship between the various FMD classes
// that handles the geometry 
//
//                               +------------+ 
//                            +- | AliFMDRing |
// 			   2  |  +------------+
//      +----------------+<>--+        |				
//      | AliFMDGeometry |             ^                       	
//      +----------------+<>--+        V 1..2                     	
//           		   3  | +----------------+ 		
//            		      +-| AliFMDDetector | 		
//             		        +----------------+		
//                                     ^
//                                     |
//                       +-------------+-------------+
//                       |             |             |	      
//                  +---------+   +---------+   +---------+
//                  | AliFMD1 |   | AliFMD2 |   | AliFMD3 |
//                  +---------+   +---------+   +---------+
//      
//
// *  AliFMDRing 
//    This class contains all stuff needed to do with a ring.  It's
//    used by the AliFMDDetector objects to instantise inner and
//    outer rings.  The AliFMDRing objects are shared by the
//    AliFMDDetector objects, and owned by the AliFMDv1 object. 
//
// *  AliFMD1, AliFMD2, and AliFMD3 
//    These are specialisation of AliFMDDetector, that contains the
//    particularities of each of the sub-detector system.  It is
//    envisioned that the classes should also define the support
//    volumes and material for each of the detectors.                          
//                                                                          
//
#include "AliFMDGeometry.h"	// ALIFMDGEOMETRY_H
#include "AliFMDRing.h"		// ALIFMDRING_H
#include "AliFMD1.h"		// ALIFMD1_H
#include "AliFMD2.h"		// ALIFMD2_H
#include "AliFMD3.h"		// ALIFMD2_H
#include "AliRecPoint.h"	// ALIRECPOINT_H
#include "AliFMDDebug.h"		   // ALILOG_H
#include <TVector3.h>           // ROOT_TVector3
// #include <TMatrix.h>            // ROOT_TMatrix
// #include <TParticle.h>          // ROOT_TParticle
#include <Riostream.h>
#include "AliFMDGeometryBuilder.h"
// #include <TArrayI.h>
#include <TGeoManager.h>
#include <TGeoVolume.h>
#include <TGeoNode.h>
static Int_t FindNodeDepth(const char* name, const char* volname);


//====================================================================
ClassImp(AliFMDGeometry)
#if 0
  ; // This is here to keep Emacs for indenting the next line
#endif

//____________________________________________________________________
AliFMDGeometry* AliFMDGeometry::fgInstance = 0;

//____________________________________________________________________
AliFMDGeometry* 
AliFMDGeometry::Instance() 
{
  // Return (newly created) singleton instance 
  if (!fgInstance) fgInstance = new AliFMDGeometry;
  return fgInstance;
}

//____________________________________________________________________
AliFMDGeometry::AliFMDGeometry() 
  : AliGeometry("FMD", "Forward multiplicity"), 
    fIsInitialized(kFALSE), 
    fInner(0),
    fOuter(0),
    fFMD1(0),
    fFMD2(0),
    fFMD3(0),
    fUseFMD1(kFALSE),
    fUseFMD2(kFALSE),
    fUseFMD3(kFALSE),
    fBuilder(0),
    fDetectorOff(0),
    fModuleOff(0),  
    fRingOff(0),
    fSectorOff(0),
    fActive(2),
    fDetailed(kFALSE),       
    fUseAssembly(kFALSE)
{
  // PROTECTED
  // Default constructor 
  fUseFMD1     = kTRUE;
  fUseFMD2     = kTRUE;
  fUseFMD3     = kTRUE;  
  fDetailed    = kTRUE;
  fUseAssembly = kTRUE;
  fInner = new AliFMDRing('I');
  fOuter = new AliFMDRing('O');
  fFMD1  = new AliFMD1(fInner);
  fFMD2  = new AliFMD2(fInner, fOuter);
  fFMD3  = new AliFMD3(fInner, fOuter);
  fIsInitialized = kFALSE;
  fActive.Reset(-1);
}

//____________________________________________________________________
AliFMDGeometry::AliFMDGeometry(const AliFMDGeometry& other) 
  : AliGeometry(other),
    fIsInitialized(other.fIsInitialized),
    fInner(other.fInner), 
    fOuter(other.fOuter), 
    fFMD1(other.fFMD1), 
    fFMD2(other.fFMD2), 
    fFMD3(other.fFMD3), 
    fUseFMD1(other.fUseFMD1), 
    fUseFMD2(other.fUseFMD2), 
    fUseFMD3(other.fUseFMD3), 
    fBuilder(other.fBuilder),
    fDetectorOff(other.fDetectorOff),
    fModuleOff(other.fModuleOff),  
    fRingOff(other.fRingOff),
    fSectorOff(other.fSectorOff),
    fActive(other.fActive),
    fDetailed(other.fDetailed),
    fUseAssembly(other.fUseAssembly)
{
  // PROTECTED
  // Copy constructor
}


//____________________________________________________________________
AliFMDGeometry&
AliFMDGeometry::operator=(const AliFMDGeometry& other) 
{
  // PROTECTED
  // Assignment operator 
  fUseFMD1		= other.fUseFMD1; 
  fUseFMD2		= other.fUseFMD2; 
  fUseFMD3		= other.fUseFMD3; 
  fFMD1			= other.fFMD1; 
  fFMD2			= other.fFMD2; 
  fFMD3			= other.fFMD3; 
  fInner		= other.fInner; 
  fOuter		= other.fOuter; 
  fIsInitialized	= other.fIsInitialized;
  return *this;
}

//____________________________________________________________________
void
AliFMDGeometry::Init()
{
  // Initialize the the singleton if not done so already 
  if (fIsInitialized) return;
  fInner->Init();
  fOuter->Init();
  fFMD1->Init();
  fFMD2->Init();
  fFMD3->Init();
}

//____________________________________________________________________
void
AliFMDGeometry::InitTransformations()
{
  // Find all local <-> global transforms 
  if (!gGeoManager) {
    AliError("No TGeoManager defined");
    return;
  }
  AliFMDDebug(0, ("Initialising transforms for FMD geometry"));
  if (fFMD1) fFMD1->InitTransformations();
  if (fFMD2) fFMD2->InitTransformations();
  if (fFMD3) fFMD3->InitTransformations();
}

//____________________________________________________________________
void
AliFMDGeometry::Build()
{
  // Build the geometry 
  if (!fBuilder) fBuilder = new AliFMDGeometryBuilder(fDetailed);
  fBuilder->SetDetailed(fDetailed);
  fBuilder->UseAssembly(fUseAssembly);
  fBuilder->Exec();
}

//____________________________________________________________________
void
AliFMDGeometry::SetActive(Int_t* active, Int_t n) 
{
  // Set active volumes 
  fActive.Set(n);
  for (Int_t i = 0; i < n; i++) { 
    AliFMDDebug(1, ("Active vol id # %d: %d", i, active[i]));
    fActive[i] = active[i];
  }
}

//____________________________________________________________________
void
AliFMDGeometry::AddActive(Int_t active)
{
  // Add an active volume 
  Int_t n = fActive.fN;
  fActive.Set(n+1);
  fActive[n] = active;
}

//____________________________________________________________________
Bool_t
AliFMDGeometry::IsActive(Int_t vol) const
{
  // Check if a volume is active 
  for (Int_t i = 0; i < fActive.fN; i++) 
    if (fActive[i] == vol) return kTRUE;
  return kFALSE;
}
  
//____________________________________________________________________
AliFMDDetector*
AliFMDGeometry::GetDetector(Int_t i) const
{
  // Get the ith detector.   i should be one of 1, 2, or 3.  If an
  // invalid value is passed, 0 (NULL) is returned. 
  switch (i) {
  case 1: return fUseFMD1 ? static_cast<AliFMDDetector*>(fFMD1) : 0;
  case 2: return fUseFMD2 ? static_cast<AliFMDDetector*>(fFMD2) : 0;
  case 3: return fUseFMD3 ? static_cast<AliFMDDetector*>(fFMD3) : 0;
  }
  return 0;
}

//____________________________________________________________________
AliFMDRing*
AliFMDGeometry::GetRing(Char_t i) const
{
  // Get the ith ring.  i should be one of 'I' or 'O' (case
  // insensitive).  If an invalid parameter is passed, 0 (NULL) is
  // returned. 
  switch (i) {
  case 'I':
  case 'i': return fInner;
  case 'O':
  case 'o': return fOuter;
  }
  return 0;
}

//____________________________________________________________________
void
AliFMDGeometry::Enable(Int_t i)
{
  // Enable the ith detector.  i should be one of 1, 2, or 3
  switch (i) {
  case 1: fUseFMD1 = kTRUE; break;
  case 2: fUseFMD2 = kTRUE; break;
  case 3: fUseFMD3 = kTRUE; break;
  }
}

//____________________________________________________________________
void
AliFMDGeometry::Disable(Int_t i)
{
  // Disable the ith detector.  i should be one of 1, 2, or 3
  switch (i) {
  case 1: fUseFMD1 = kFALSE; break;
  case 2: fUseFMD2 = kFALSE; break;
  case 3: fUseFMD3 = kFALSE; break;
  }
}

//____________________________________________________________________
void
AliFMDGeometry::Detector2XYZ(UShort_t  detector, 
			     Char_t    ring, 
			     UShort_t  sector, 
			     UShort_t  strip, 
			     Double_t& x, 
			     Double_t& y, 
			     Double_t& z) const
{
  // Translate detector coordinates (detector, ring, sector, strip) to
  // spatial coordinates (x, y, z) in the master reference frame of
  // ALICE. 
  AliFMDDetector* det = GetDetector(detector);
  if (!det) { 
    AliWarning(Form("Unknown detector %d", detector));
    return;
  }
  det->Detector2XYZ(ring, sector, strip, x, y, z);
}

//____________________________________________________________________
Bool_t
AliFMDGeometry::XYZ2Detector(Double_t  x, 
			     Double_t  y, 
			     Double_t  z,
			     UShort_t& detector, 
			     Char_t&   ring, 
			     UShort_t& sector, 
			     UShort_t& strip) const
{
  // Translate spatial coordinates (x,y,z) in the master reference frame of
  // ALICE to the detector coordinates (detector, ring, sector,
  // strip).  Note, that if this method is to be used in
  // reconstruction or the like, then the input z-coordinate should be
  // corrected for the events interactions points z-coordinate, like 
  // geom->XYZ2Detector(x,y,z-ipz,d,r,s,t);
  AliFMDDetector* det = 0;
  detector = 0;
  for (int i = 1; i <= 3; i++) {
    det = GetDetector(i);
    if (!det) continue;
    if (det->XYZ2Detector(x, y, z, ring, sector, strip)) {
      detector = det->GetId();
      return kTRUE;
    }
  }
  return kFALSE;
}


//____________________________________________________________________
void
AliFMDGeometry::GetGlobal(const AliRecPoint* p, 
			  TVector3& pos, 
			  TMatrixF& /* mat */) const 
{
  // Get the global coordinates cooresponding to the reconstructed
  // point p.  The coordiates is returned in the 3-vector pos passed
  // to this member function.  The matrix mat is used for rotations. 
  GetGlobal(p, pos);
}

//____________________________________________________________________
void
AliFMDGeometry::GetGlobal(const AliRecPoint* p, TVector3& pos) const 
{
  // Get the global coordinates cooresponding to the reconstructed
  // point p.  The coordiates is returned in the 3-vector pos passed
  // to this member function. Note, as AliRecPoint only has places for
  // 3 indicies, it is assumed that the ring hit is an inner ring -
  // which obviously needn't be the case. This makes the member
  // function pretty darn useless. 
  // FIXME: Implement this function to work with outer rings too. 
  Double_t x, y, z;
  TVector3 local;
  p->GetLocalPosition(local);
  UShort_t detector = UShort_t(local.X());
  UShort_t sector   = UShort_t(local.Y());
  UShort_t strip    = UShort_t(local.Z());
  Detector2XYZ(detector, 'I', sector, strip, x, y, z);
  pos.SetXYZ(x, y, z);
}

//____________________________________________________________________
Bool_t
AliFMDGeometry::Impact(const TParticle* /* particle */) const 
{ 
  // Return true, if the particle will hit the active detector
  // elements, and false if not.  Should be used for fast
  // simulations.  Note, that the function currently return false
  // always.  
  // FIXME: Implement this function. 
  return kFALSE; 
}

//____________________________________________________________________	
void  
AliFMDGeometry::SetAlignableVolumes() const
{
  // Declare alignable volumes
  for (Int_t d = 1; d <= 3; d++) 
    if (GetDetector(d)) GetDetector(d)->SetAlignableVolumes();
}


//____________________________________________________________________	
void  
AliFMDGeometry::ExtractGeomInfo()
{
  // Check the volume depth of some nodes, get the active volume
  // numbers, and so forth. 
  // 
  // TODO: Here, we should actually also get the parameters of the
  // shapes, like the verticies of the polygon shape that makes up the
  // silicon sensor, the strip pitch, the ring radii, the z-positions,
  // and so on - that is, all the geometric information we need for
  // futher processing, such as simulation, digitization,
  // reconstruction, etc. 
  Int_t detectorDepth = FindNodeDepth("FMD1_1", "ALIC");
  Int_t ringDepth     = FindNodeDepth(Form("FMDI_%d", Int_t('I')), "ALIC");
  Int_t moduleDepth   = FindNodeDepth("FIFV_0", "ALIC");
  Int_t sectorDepth   = FindNodeDepth("FISE_1", "ALIC");
  fActive.Reset(-1);
  AliFMDDebug(1, ("Geometry depths:\n"
		   "   Sector:     %d\n"
		   "   Module:     %d\n"
		   "   Ring:       %d\n"
		   "   Detector:   %d", 
		   sectorDepth, moduleDepth, ringDepth, detectorDepth));
  if (sectorDepth < 0 && moduleDepth < 0) {
    fDetailed    = kFALSE;
    fSectorOff   = -1;
    fModuleOff   = -1;
    fRingOff     = 0;
    fDetectorOff = (ringDepth - detectorDepth);
    TGeoVolume* actiVol = gGeoManager->GetVolume("FIAC");
    TGeoVolume* actoVol = gGeoManager->GetVolume("FOAC");
    if (actiVol) AddActive(actiVol->GetNumber());
    if (actiVol) AddActive(actoVol->GetNumber());
  }
  else if (sectorDepth < 0) {
    fDetailed    = kFALSE;
    fSectorOff   = -1;
    fModuleOff   = 1;
    fRingOff     = (moduleDepth - ringDepth) + 1;
    fDetectorOff = (moduleDepth - detectorDepth) + 1;
    TGeoVolume* modiVol = gGeoManager->GetVolume("FIMO");
    TGeoVolume* modoVol = gGeoManager->GetVolume("FOMO");
    if (modiVol) AddActive(modiVol->GetNumber());
    if (modoVol) AddActive(modoVol->GetNumber());
  }
  else {
    Int_t stripDepth    = FindNodeDepth("FIST_1", "ALIC");
    fDetailed    = kTRUE;
    fSectorOff   = (stripDepth - sectorDepth);
    fModuleOff   = (moduleDepth >= 0 ? (stripDepth - moduleDepth) : -1);
    fRingOff     = (stripDepth - ringDepth);
    fDetectorOff = (stripDepth - detectorDepth );
    TGeoVolume* striVol = gGeoManager->GetVolume("FIST");
    TGeoVolume* stroVol = gGeoManager->GetVolume("FOST");
    if (striVol) AddActive(striVol->GetNumber());
    if (stroVol) AddActive(stroVol->GetNumber());
  }    
  AliFMDDebug(1, ("Geometry offsets:\n"
		   "   Sector:     %d\n"
		   "   Module:     %d\n"
		   "   Ring:       %d\n"
		   "   Detector:   %d", 
		   fSectorOff, fModuleOff, fRingOff, fDetectorOff));
}

  
//____________________________________________________________________	
static Int_t 
CheckNodes(TGeoNode* node, const char* name, Int_t& lvl)
{
  // If there's no node here. 
  if (!node) return -1;
  // Check if it this one 
  TString sname(name);
  if (sname == node->GetName()) return lvl;

  // Check if the node is an immediate daugther 
  TObjArray* nodes = node->GetNodes();
  if (!nodes) return -1;
  // Increase the level, and search immediate sub nodes. 
  lvl++;
  TGeoNode*  found = static_cast<TGeoNode*>(nodes->FindObject(name));
  if (found) return lvl;

  // Check the sub node, if any of their sub-nodes match.
  for (Int_t i = 0; i < nodes->GetEntries(); i++) {
    TGeoNode* sub = static_cast<TGeoNode*>(nodes->At(i));
    if (!sub) continue;
    // Recurive check 
    if (CheckNodes(sub, name, lvl) >= 0) return lvl;
  }
  // If not found, decrease the level 
  lvl--;
  return -1;
}
//____________________________________________________________________	
Int_t 
FindNodeDepth(const char* name, const char* volname) 
{
  // Find the depth of a node 
  TGeoVolume* vol  = gGeoManager->GetVolume(volname);
  if (!vol) {
    std::cerr << "No top volume defined" << std::endl;
    return -1;
  }
  TObjArray* nodes = vol->GetNodes();
  if (!nodes) { 
    std::cerr << "No nodes in top volume" << std::endl;
    return -1;
  }
  TIter next(nodes);
  TGeoNode* node = 0;
  Int_t lvl = 0;
  while ((node = static_cast<TGeoNode*>(next()))) 
    if (CheckNodes(node, name, lvl) >= 0) return lvl;
  return -1;
}

//____________________________________________________________________
//
// EOF
//
Commit	Line	Data
1a1fdef7	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	**************************************************************************/
1a1fdef7	15	/* $Id$ */
c2fc1258	16	/** @file AliFMDGeometry.cxx
	17	@author Christian Holm Christensen <cholm@nbi.dk>
	18	@date Mon Mar 27 12:40:37 2006
	19	@brief Geometry mananger for the FMD
	20	*/
1a1fdef7	21	//____________________________________________________________________
	22	//
	23	// Forward Multiplicity Detector based on Silicon wafers.
	24	//
	25	// This class is a singleton that handles the geometry parameters of
	26	// the FMD detectors.
	27	//
	28	// The actual code is done by various separate classes. Below is
	29	// diagram showing the relationship between the various FMD classes
	30	// that handles the geometry
	31	//
	32	// +------------+
	33	// +- \| AliFMDRing \|
	34	// 2 \| +------------+
	35	// +----------------+<>--+ \|
	36	// \| AliFMDGeometry \| ^
	37	// +----------------+<>--+ V 1..2
	38	// 3 \| +----------------+
	39	// +-\| AliFMDDetector \|
	40	// +----------------+
	41	// ^
	42	// \|
	43	// +-------------+-------------+
	44	// \| \| \|
	45	// +---------+ +---------+ +---------+
	46	// \| AliFMD1 \| \| AliFMD2 \| \| AliFMD3 \|
	47	// +---------+ +---------+ +---------+
	48	//
	49	//
	50	// * AliFMDRing
	51	// This class contains all stuff needed to do with a ring. It's
	52	// used by the AliFMDDetector objects to instantise inner and
	53	// outer rings. The AliFMDRing objects are shared by the
	54	// AliFMDDetector objects, and owned by the AliFMDv1 object.
	55	//
	56	// * AliFMD1, AliFMD2, and AliFMD3
	57	// These are specialisation of AliFMDDetector, that contains the
	58	// particularities of each of the sub-detector system. It is
	59	// envisioned that the classes should also define the support
	60	// volumes and material for each of the detectors.
	61	//
	62	//
	63	#include "AliFMDGeometry.h" // ALIFMDGEOMETRY_H
	64	#include "AliFMDRing.h" // ALIFMDRING_H
	65	#include "AliFMD1.h" // ALIFMD1_H
	66	#include "AliFMD2.h" // ALIFMD2_H
	67	#include "AliFMD3.h" // ALIFMD2_H
	68	#include "AliRecPoint.h" // ALIRECPOINT_H
f95a63c4	69	#include "AliFMDDebug.h" // ALILOG_H
1a1fdef7	70	#include <TVector3.h> // ROOT_TVector3
02a27b50	71	// #include <TMatrix.h> // ROOT_TMatrix
02a27b50	72	// #include <TParticle.h> // ROOT_TParticle
1a1fdef7	73	#include <Riostream.h>
54e415a8	74	#include "AliFMDGeometryBuilder.h"
02a27b50	75	// #include <TArrayI.h>
54e415a8	76	#include <TGeoManager.h>
	77	#include <TGeoVolume.h>
	78	#include <TGeoNode.h>
	79	static Int_t FindNodeDepth(const char* name, const char* volname);
54e415a8	80
1a1fdef7	81
	82	//====================================================================
	83	ClassImp(AliFMDGeometry)
	84	#if 0
	85	; // This is here to keep Emacs for indenting the next line
	86	#endif
	87
	88	//____________________________________________________________________
	89	AliFMDGeometry* AliFMDGeometry::fgInstance = 0;
	90
	91	//____________________________________________________________________
	92	AliFMDGeometry*
	93	AliFMDGeometry::Instance()
	94	{
69b696b9	95	// Return (newly created) singleton instance
1a1fdef7	96	if (!fgInstance) fgInstance = new AliFMDGeometry;
	97	return fgInstance;
	98	}
	99
	100	//____________________________________________________________________
	101	AliFMDGeometry::AliFMDGeometry()
a1f80595	102	: AliGeometry("FMD", "Forward multiplicity"),
b5ee4425	103	fIsInitialized(kFALSE),
	104	fInner(0),
	105	fOuter(0),
	106	fFMD1(0),
	107	fFMD2(0),
	108	fFMD3(0),
	109	fUseFMD1(kFALSE),
	110	fUseFMD2(kFALSE),
	111	fUseFMD3(kFALSE),
	112	fBuilder(0),
	113	fDetectorOff(0),
	114	fModuleOff(0),
	115	fRingOff(0),
	116	fSectorOff(0),
	117	fActive(2),
	118	fDetailed(kFALSE),
	119	fUseAssembly(kFALSE)
1a1fdef7	120	{
69b696b9	121	// PROTECTED
69b696b9	122	// Default constructor
54e415a8	123	fUseFMD1 = kTRUE;
	124	fUseFMD2 = kTRUE;
	125	fUseFMD3 = kTRUE;
54e415a8	126	fDetailed = kTRUE;
54e415a8	127	fUseAssembly = kTRUE;
1a1fdef7	128	fInner = new AliFMDRing('I');
	129	fOuter = new AliFMDRing('O');
	130	fFMD1 = new AliFMD1(fInner);
	131	fFMD2 = new AliFMD2(fInner, fOuter);
	132	fFMD3 = new AliFMD3(fInner, fOuter);
	133	fIsInitialized = kFALSE;
54e415a8	134	fActive.Reset(-1);
1a1fdef7	135	}
1a1fdef7	136
69b696b9	137	//____________________________________________________________________
	138	AliFMDGeometry::AliFMDGeometry(const AliFMDGeometry& other)
	139	: AliGeometry(other),
	140	fIsInitialized(other.fIsInitialized),
	141	fInner(other.fInner),
	142	fOuter(other.fOuter),
	143	fFMD1(other.fFMD1),
	144	fFMD2(other.fFMD2),
	145	fFMD3(other.fFMD3),
	146	fUseFMD1(other.fUseFMD1),
	147	fUseFMD2(other.fUseFMD2),
bf000c32	148	fUseFMD3(other.fUseFMD3),
b5ee4425	149	fBuilder(other.fBuilder),
	150	fDetectorOff(other.fDetectorOff),
	151	fModuleOff(other.fModuleOff),
	152	fRingOff(other.fRingOff),
	153	fSectorOff(other.fSectorOff),
bf000c32	154	fActive(other.fActive),
54e415a8	155	fDetailed(other.fDetailed),
54e415a8	156	fUseAssembly(other.fUseAssembly)
69b696b9	157	{
	158	// PROTECTED
	159	// Copy constructor
	160	}
	161
	162
	163
	164	//____________________________________________________________________
	165	AliFMDGeometry&
	166	AliFMDGeometry::operator=(const AliFMDGeometry& other)
	167	{
	168	// PROTECTED
	169	// Assignment operator
	170	fUseFMD1 = other.fUseFMD1;
	171	fUseFMD2 = other.fUseFMD2;
	172	fUseFMD3 = other.fUseFMD3;
	173	fFMD1 = other.fFMD1;
	174	fFMD2 = other.fFMD2;
	175	fFMD3 = other.fFMD3;
	176	fInner = other.fInner;
	177	fOuter = other.fOuter;
	178	fIsInitialized = other.fIsInitialized;
	179	return *this;
	180	}
	181
1a1fdef7	182	//____________________________________________________________________
	183	void
	184	AliFMDGeometry::Init()
	185	{
69b696b9	186	// Initialize the the singleton if not done so already
1a1fdef7	187	if (fIsInitialized) return;
	188	fInner->Init();
	189	fOuter->Init();
	190	fFMD1->Init();
	191	fFMD2->Init();
	192	fFMD3->Init();
	193	}
	194
bf000c32	195	//____________________________________________________________________
	196	void
	197	AliFMDGeometry::InitTransformations()
	198	{
02a27b50	199	// Find all local <-> global transforms
bf000c32	200	if (!gGeoManager) {
	201	AliError("No TGeoManager defined");
	202	return;
	203	}
f95a63c4	204	AliFMDDebug(0, ("Initialising transforms for FMD geometry"));
bf000c32	205	if (fFMD1) fFMD1->InitTransformations();
	206	if (fFMD2) fFMD2->InitTransformations();
	207	if (fFMD3) fFMD3->InitTransformations();
	208	}
	209
54e415a8	210	//____________________________________________________________________
	211	void
	212	AliFMDGeometry::Build()
	213	{
02a27b50	214	// Build the geometry
54e415a8	215	if (!fBuilder) fBuilder = new AliFMDGeometryBuilder(fDetailed);
	216	fBuilder->SetDetailed(fDetailed);
	217	fBuilder->UseAssembly(fUseAssembly);
	218	fBuilder->Exec();
	219	}
	220
	221	//____________________________________________________________________
	222	void
	223	AliFMDGeometry::SetActive(Int_t* active, Int_t n)
	224	{
02a27b50	225	// Set active volumes
54e415a8	226	fActive.Set(n);
088f8e79	227	for (Int_t i = 0; i < n; i++) {
f95a63c4	228	AliFMDDebug(1, ("Active vol id # %d: %d", i, active[i]));
088f8e79	229	fActive[i] = active[i];
088f8e79	230	}
54e415a8	231	}
	232
	233	//____________________________________________________________________
	234	void
	235	AliFMDGeometry::AddActive(Int_t active)
	236	{
02a27b50	237	// Add an active volume
54e415a8	238	Int_t n = fActive.fN;
	239	fActive.Set(n+1);
	240	fActive[n] = active;
	241	}
	242
	243	//____________________________________________________________________
	244	Bool_t
	245	AliFMDGeometry::IsActive(Int_t vol) const
	246	{
02a27b50	247	// Check if a volume is active
54e415a8	248	for (Int_t i = 0; i < fActive.fN; i++)
	249	if (fActive[i] == vol) return kTRUE;
	250	return kFALSE;
	251	}
54e415a8	252
1a1fdef7	253	//____________________________________________________________________
	254	AliFMDDetector*
	255	AliFMDGeometry::GetDetector(Int_t i) const
	256	{
69b696b9	257	// Get the ith detector. i should be one of 1, 2, or 3. If an
69b696b9	258	// invalid value is passed, 0 (NULL) is returned.
1a1fdef7	259	switch (i) {
	260	case 1: return fUseFMD1 ? static_cast<AliFMDDetector*>(fFMD1) : 0;
	261	case 2: return fUseFMD2 ? static_cast<AliFMDDetector*>(fFMD2) : 0;
	262	case 3: return fUseFMD3 ? static_cast<AliFMDDetector*>(fFMD3) : 0;
	263	}
	264	return 0;
	265	}
	266
	267	//____________________________________________________________________
	268	AliFMDRing*
	269	AliFMDGeometry::GetRing(Char_t i) const
	270	{
69b696b9	271	// Get the ith ring. i should be one of 'I' or 'O' (case
	272	// insensitive). If an invalid parameter is passed, 0 (NULL) is
	273	// returned.
1a1fdef7	274	switch (i) {
	275	case 'I':
	276	case 'i': return fInner;
	277	case 'O':
	278	case 'o': return fOuter;
	279	}
	280	return 0;
	281	}
	282
	283	//____________________________________________________________________
	284	void
	285	AliFMDGeometry::Enable(Int_t i)
	286	{
69b696b9	287	// Enable the ith detector. i should be one of 1, 2, or 3
1a1fdef7	288	switch (i) {
	289	case 1: fUseFMD1 = kTRUE; break;
	290	case 2: fUseFMD2 = kTRUE; break;
	291	case 3: fUseFMD3 = kTRUE; break;
	292	}
	293	}
	294
	295	//____________________________________________________________________
	296	void
	297	AliFMDGeometry::Disable(Int_t i)
	298	{
69b696b9	299	// Disable the ith detector. i should be one of 1, 2, or 3
1a1fdef7	300	switch (i) {
	301	case 1: fUseFMD1 = kFALSE; break;
	302	case 2: fUseFMD2 = kFALSE; break;
	303	case 3: fUseFMD3 = kFALSE; break;
	304	}
	305	}
	306
	307	//____________________________________________________________________
	308	void
	309	AliFMDGeometry::Detector2XYZ(UShort_t detector,
69b696b9	310	Char_t ring,
	311	UShort_t sector,
	312	UShort_t strip,
	313	Double_t& x,
	314	Double_t& y,
	315	Double_t& z) const
1a1fdef7	316	{
69b696b9	317	// Translate detector coordinates (detector, ring, sector, strip) to
	318	// spatial coordinates (x, y, z) in the master reference frame of
	319	// ALICE.
1a1fdef7	320	AliFMDDetector* det = GetDetector(detector);
bf000c32	321	if (!det) {
	322	AliWarning(Form("Unknown detector %d", detector));
	323	return;
	324	}
1a1fdef7	325	det->Detector2XYZ(ring, sector, strip, x, y, z);
	326	}
	327
54e415a8	328	//____________________________________________________________________
	329	Bool_t
	330	AliFMDGeometry::XYZ2Detector(Double_t x,
	331	Double_t y,
	332	Double_t z,
	333	UShort_t& detector,
	334	Char_t& ring,
	335	UShort_t& sector,
	336	UShort_t& strip) const
	337	{
	338	// Translate spatial coordinates (x,y,z) in the master reference frame of
	339	// ALICE to the detector coordinates (detector, ring, sector,
	340	// strip). Note, that if this method is to be used in
	341	// reconstruction or the like, then the input z-coordinate should be
	342	// corrected for the events interactions points z-coordinate, like
	343	// geom->XYZ2Detector(x,y,z-ipz,d,r,s,t);
	344	AliFMDDetector* det = 0;
	345	detector = 0;
	346	for (int i = 1; i <= 3; i++) {
	347	det = GetDetector(i);
	348	if (!det) continue;
	349	if (det->XYZ2Detector(x, y, z, ring, sector, strip)) {
	350	detector = det->GetId();
	351	return kTRUE;
	352	}
	353	}
	354	return kFALSE;
	355	}
	356
1a1fdef7	357
	358	//____________________________________________________________________
	359	void
	360	AliFMDGeometry::GetGlobal(const AliRecPoint* p,
	361	TVector3& pos,
e8d02863	362	TMatrixF& /* mat */) const
1a1fdef7	363	{
69b696b9	364	// Get the global coordinates cooresponding to the reconstructed
	365	// point p. The coordiates is returned in the 3-vector pos passed
	366	// to this member function. The matrix mat is used for rotations.
1a1fdef7	367	GetGlobal(p, pos);
	368	}
	369
	370	//____________________________________________________________________
	371	void
	372	AliFMDGeometry::GetGlobal(const AliRecPoint* p, TVector3& pos) const
	373	{
69b696b9	374	// Get the global coordinates cooresponding to the reconstructed
	375	// point p. The coordiates is returned in the 3-vector pos passed
	376	// to this member function. Note, as AliRecPoint only has places for
	377	// 3 indicies, it is assumed that the ring hit is an inner ring -
	378	// which obviously needn't be the case. This makes the member
	379	// function pretty darn useless.
	380	// FIXME: Implement this function to work with outer rings too.
1a1fdef7	381	Double_t x, y, z;
	382	TVector3 local;
	383	p->GetLocalPosition(local);
	384	UShort_t detector = UShort_t(local.X());
	385	UShort_t sector = UShort_t(local.Y());
	386	UShort_t strip = UShort_t(local.Z());
	387	Detector2XYZ(detector, 'I', sector, strip, x, y, z);
	388	pos.SetXYZ(x, y, z);
	389	}
	390
	391	//____________________________________________________________________
	392	Bool_t
	393	AliFMDGeometry::Impact(const TParticle* /* particle */) const
	394	{
69b696b9	395	// Return true, if the particle will hit the active detector
	396	// elements, and false if not. Should be used for fast
	397	// simulations. Note, that the function currently return false
	398	// always.
	399	// FIXME: Implement this function.
1a1fdef7	400	return kFALSE;
	401	}
	402
9de78b35	403	//____________________________________________________________________
	404	void
	405	AliFMDGeometry::SetAlignableVolumes() const
	406	{
	407	// Declare alignable volumes
	408	for (Int_t d = 1; d <= 3; d++)
	409	if (GetDetector(d)) GetDetector(d)->SetAlignableVolumes();
	410	}
	411
	412
54e415a8	413	//____________________________________________________________________
	414	void
	415	AliFMDGeometry::ExtractGeomInfo()
	416	{
	417	// Check the volume depth of some nodes, get the active volume
	418	// numbers, and so forth.
	419	//
	420	// TODO: Here, we should actually also get the parameters of the
	421	// shapes, like the verticies of the polygon shape that makes up the
	422	// silicon sensor, the strip pitch, the ring radii, the z-positions,
	423	// and so on - that is, all the geometric information we need for
	424	// futher processing, such as simulation, digitization,
	425	// reconstruction, etc.
	426	Int_t detectorDepth = FindNodeDepth("FMD1_1", "ALIC");
	427	Int_t ringDepth = FindNodeDepth(Form("FMDI_%d", Int_t('I')), "ALIC");
	428	Int_t moduleDepth = FindNodeDepth("FIFV_0", "ALIC");
	429	Int_t sectorDepth = FindNodeDepth("FISE_1", "ALIC");
	430	fActive.Reset(-1);
f95a63c4	431	AliFMDDebug(1, ("Geometry depths:\n"
54e415a8	432	" Sector: %d\n"
	433	" Module: %d\n"
	434	" Ring: %d\n"
	435	" Detector: %d",
	436	sectorDepth, moduleDepth, ringDepth, detectorDepth));
	437	if (sectorDepth < 0 && moduleDepth < 0) {
	438	fDetailed = kFALSE;
	439	fSectorOff = -1;
	440	fModuleOff = -1;
	441	fRingOff = 0;
	442	fDetectorOff = (ringDepth - detectorDepth);
	443	TGeoVolume* actiVol = gGeoManager->GetVolume("FIAC");
	444	TGeoVolume* actoVol = gGeoManager->GetVolume("FOAC");
	445	if (actiVol) AddActive(actiVol->GetNumber());
	446	if (actiVol) AddActive(actoVol->GetNumber());
	447	}
	448	else if (sectorDepth < 0) {
	449	fDetailed = kFALSE;
	450	fSectorOff = -1;
	451	fModuleOff = 1;
	452	fRingOff = (moduleDepth - ringDepth) + 1;
	453	fDetectorOff = (moduleDepth - detectorDepth) + 1;
	454	TGeoVolume* modiVol = gGeoManager->GetVolume("FIMO");
	455	TGeoVolume* modoVol = gGeoManager->GetVolume("FOMO");
	456	if (modiVol) AddActive(modiVol->GetNumber());
	457	if (modoVol) AddActive(modoVol->GetNumber());
	458	}
	459	else {
	460	Int_t stripDepth = FindNodeDepth("FIST_1", "ALIC");
	461	fDetailed = kTRUE;
	462	fSectorOff = (stripDepth - sectorDepth);
	463	fModuleOff = (moduleDepth >= 0 ? (stripDepth - moduleDepth) : -1);
	464	fRingOff = (stripDepth - ringDepth);
	465	fDetectorOff = (stripDepth - detectorDepth );
	466	TGeoVolume* striVol = gGeoManager->GetVolume("FIST");
	467	TGeoVolume* stroVol = gGeoManager->GetVolume("FOST");
	468	if (striVol) AddActive(striVol->GetNumber());
	469	if (stroVol) AddActive(stroVol->GetNumber());
	470	}
f95a63c4	471	AliFMDDebug(1, ("Geometry offsets:\n"
54e415a8	472	" Sector: %d\n"
	473	" Module: %d\n"
	474	" Ring: %d\n"
	475	" Detector: %d",
	476	fSectorOff, fModuleOff, fRingOff, fDetectorOff));
	477	}
	478
	479
	480	//____________________________________________________________________
	481	static Int_t
	482	CheckNodes(TGeoNode* node, const char* name, Int_t& lvl)
	483	{
	484	// If there's no node here.
	485	if (!node) return -1;
	486	// Check if it this one
	487	TString sname(name);
	488	if (sname == node->GetName()) return lvl;
	489
	490	// Check if the node is an immediate daugther
	491	TObjArray* nodes = node->GetNodes();
	492	if (!nodes) return -1;
	493	// Increase the level, and search immediate sub nodes.
	494	lvl++;
	495	TGeoNode* found = static_cast<TGeoNode*>(nodes->FindObject(name));
	496	if (found) return lvl;
	497
	498	// Check the sub node, if any of their sub-nodes match.
	499	for (Int_t i = 0; i < nodes->GetEntries(); i++) {
	500	TGeoNode* sub = static_cast<TGeoNode*>(nodes->At(i));
	501	if (!sub) continue;
	502	// Recurive check
	503	if (CheckNodes(sub, name, lvl) >= 0) return lvl;
	504	}
	505	// If not found, decrease the level
	506	lvl--;
	507	return -1;
	508	}
	509	//____________________________________________________________________
	510	Int_t
	511	FindNodeDepth(const char* name, const char* volname)
	512	{
02a27b50	513	// Find the depth of a node
54e415a8	514	TGeoVolume* vol = gGeoManager->GetVolume(volname);
	515	if (!vol) {
	516	std::cerr << "No top volume defined" << std::endl;
	517	return -1;
	518	}
	519	TObjArray* nodes = vol->GetNodes();
	520	if (!nodes) {
	521	std::cerr << "No nodes in top volume" << std::endl;
	522	return -1;
	523	}
	524	TIter next(nodes);
	525	TGeoNode* node = 0;
	526	Int_t lvl = 0;
	527	while ((node = static_cast<TGeoNode*>(next())))
	528	if (CheckNodes(node, name, lvl) >= 0) return lvl;
	529	return -1;
	530	}
54e415a8	531
1a1fdef7	532	//____________________________________________________________________
	533	//
	534	// EOF
	535	//