Fixing Doxygen warnings
[u/mrichter/AliRoot.git] / MUON / mapping / AliMpSector.cxx
index 8f01df1..1e2b913 100755 (executable)
@@ -1,13 +1,29 @@
+/**************************************************************************
+ * 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$
+// $MpId: AliMpSector.cxx,v 1.14 2006/05/24 13:58:46 ivana Exp $
 // Category: sector
-//
+
+//-----------------------------------------------------------------------------
 // Class AliMpSector
 // -----------------
 // Class describing the sector of the MUON chamber of station 1.
-//
+// Included in AliRoot: 2003/05/02
 // Authors: David Guez, Ivana Hrivnacova; IPN Orsay
-
-#include <Riostream.h>
+//-----------------------------------------------------------------------------
 
 #include "AliMpSector.h"
 #include "AliMpSectorPadIterator.h"
 #include "AliMpVRowSegment.h"
 #include "AliMpVMotif.h"
 #include "AliMpMotifMap.h"
-#include "AliMpIntPair.h"
+#include "AliMpEncodePair.h"
 #include "AliMpConstants.h"
 
+#include "AliLog.h"
+
+#include <Riostream.h>
+
+/// \cond CLASSIMP
 ClassImp(AliMpSector)
+/// \endcond
 
 //_____________________________________________________________________________
-AliMpSector::AliMpSector(TString id, Int_t nofZones, Int_t nofRows, 
-                         AliMpDirection direction) 
-  : TObject(),
+AliMpSector::AliMpSector(const TString& id, Int_t nofZones, Int_t nofRows, 
+                         AliMp::Direction direction, 
+                         Double_t offsetx, Double_t offsety) 
+  : TNamed("Sector", ""),
     fID(id),
-    fOffset(TVector2(0., 0.)),
+    fOffsetX(offsetx),
+    fOffsetY(offsety),
+    fDimensionX(0.),
+    fDimensionY(0.),
     fZones(),
     fRows(),
+    fMotifMap(0),
     fDirection(direction),
-    fMinPadDimensions(TVector2(1.e6, 1.e6))
+    fMinPadDimensionX(1.e6),
+    fMinPadDimensionY(1.e6),
+    fMaxPadDimensionX(0.),
+    fMaxPadDimensionY(0.),
+    fLMaxPadIndices(0),
+    fNofPads(0)
 {
-//
-  fMotifMap = new AliMpMotifMap();
+/// Standard constructor
+
+  AliDebugStream(1) << "this = " << this << endl;
+
+  fMotifMap = new AliMpMotifMap;
 
   for (Int_t izone = 0; izone<nofZones; izone++) 
-    fZones.push_back(new AliMpZone(izone+1));
+    fZones.Add(new AliMpZone(izone+1));
     
   for (Int_t irow = 0; irow<nofRows; irow++) 
-    fRows.push_back(new AliMpRow(irow, fMotifMap));
+    fRows.Add(new AliMpRow(irow, fMotifMap));
     
 }
 
 //_____________________________________________________________________________
 AliMpSector::AliMpSector() 
-  : TObject(),
+  : TNamed(),
     fID(""),    
-    fOffset(TVector2(0., 0.)),
+    fOffsetX(0.),
+    fOffsetY(0.),
+    fDimensionX(0.),
+    fDimensionY(0.),
     fZones(),
     fRows(),
     fMotifMap(0),
-    fDirection(kX),
-    fMinPadDimensions(TVector2(0., 0.))
+    fDirection(AliMp::kX),
+    fMinPadDimensionX(0.),
+    fMinPadDimensionY(0.),
+    fMaxPadDimensionX(0.),
+    fMaxPadDimensionY(0.),
+    fLMaxPadIndices(0),
+    fNofPads(0)
 {
-//
+/// Default constructor
+
+  AliDebugStream(1) << "this = " << this << endl;
 }
 
 //_____________________________________________________________________________
-AliMpSector::~AliMpSector() {
-// 
+AliMpSector::~AliMpSector() 
+{
+/// Destructor 
+
+  AliDebugStream(1) << "this = " << this << endl;
+
   // deletes 
   for (Int_t izone = 0; izone<GetNofZones(); izone++) 
     delete fZones[izone];
@@ -75,26 +124,48 @@ AliMpSector::~AliMpSector() {
 //
 
 //_____________________________________________________________________________
-AliMpVPadIterator* AliMpSector::CreateIterator() const
+AliMpRow* AliMpSector::FindRow(Double_t y) const
 {
-  return new AliMpSectorPadIterator(this);
+/// Find the row for the specified y position.                              \n
+/// If y is on border the lowest row is returned.
+  
+  for (Int_t i=0; i<GetNofRows(); i++) {
+    if ( y >= ((AliMpRow*)fRows[i])->LowBorderY() && 
+         y <= ((AliMpRow*)fRows[i])->UpperBorderY())
+      return (AliMpRow*)fRows[i];
+  }    
+  
+  return 0;
 }
 
+//_____________________________________________________________________________
+Int_t AliMpSector::FindMotifPositionId(Double_t x, Double_t y) const
+{
+/// Find the motif position ID in the specified position.                   \n
+/// Return 0 if no motif is found.
+  // Find the row segment
+  AliMpVRowSegment* rowSegment = FindRowSegment(x,y);
+  
+  if ( ! rowSegment ) return 0;
+    
+  // Find motif position ID
+  return rowSegment->FindMotifPositionId(x, y);  
+}
 
 //_____________________________________________________________________________
-AliMpVRowSegment* AliMpSector::FindRowSegment(const TVector2& position) const
+AliMpVRowSegment* AliMpSector::FindRowSegment(Double_t x, Double_t y) const
 {
-// Finds the row segment in the specified position.
-// Returns 0 if no motif is found.
-// ---
+/// Find the row segment in the specified position.                         \n
+/// Return if no motif is found.
   
   // Find row
-  AliMpRow* row = FindRow(position);
+  AliMpRow* row = FindRow(y);
   
   if (!row) return 0;
 
   // Find the row segment and return its motif
-  AliMpVRowSegment* rowSegment = row->FindRowSegment(position.X());
+  AliMpVRowSegment* rowSegment = row->FindRowSegment(x);
   
   return rowSegment;
 }
@@ -102,97 +173,158 @@ AliMpVRowSegment* AliMpSector::FindRowSegment(const TVector2& position) const
 //_____________________________________________________________________________
 void  AliMpSector::SetRowOffsets()
 {
-// For each row checks consitency of the row segments
-// and calculates the row offset.
-// ---
+/// For each row check consitency of the row segments
+/// and calculate the row offset.
 
-  Double_t offset = fOffset.Y();
+  Double_t offset = fOffsetY;
   
-  for (UInt_t irow=0; irow<fRows.size(); irow++)
+  for (Int_t irow=0; irow<GetNofRows(); irow++)
     offset = GetRow(irow)->SetOffsetY(offset);    
 }
 
 //_____________________________________________________________________________
 void  AliMpSector::SetMotifPositions()
 {
-// Creates motif positions objects and fills them in the motif map.
-// ---
+/// Create motif positions objects and fills them in the motif map.
 
-  for (UInt_t i=0; i<fRows.size(); i++)
+  for (Int_t i=0; i<GetNofRows(); i++)
     GetRow(i)->SetMotifPositions();
 }
 
 //_____________________________________________________________________________
 void  AliMpSector::SetGlobalIndices()
 {
-// Set the indices limits to all indexed elements
-// (row, row segment, motif positions).
-// ---
+/// Set the indices limits to all indexed elements
+/// (row, row segment, motif positions).
 
-  AliMpIntPair indices(0,0); 
   AliMpRow* rowBefore=0;
-  for (UInt_t i=0; i<fRows.size(); i++) {
+  for (Int_t i=0; i<GetNofRows(); i++) {
     GetRow(i)->SetGlobalIndices(fDirection, rowBefore);
     rowBefore = GetRow(i);
   }
 }
 
 //_____________________________________________________________________________
-void  AliMpSector::SetMinPadDimensions()
+void  AliMpSector::SetMinMaxPadDimensions()
 {
-// Sets the minimal pad dimensions.
-// ---
+/// Set the minimal pad dimensions.
 
   for (Int_t i=1; i<GetNofZones()+1; i++) {
-    TVector2 padDimensions = GetZone(i)->GetPadDimensions();
+    Double_t dx = GetZone(i)->GetPadDimensionX();
+    Double_t dy = GetZone(i)->GetPadDimensionY();
     
-    if ( fDirection == kX &&  
-         padDimensions.Y() > 0. && padDimensions.Y() < fMinPadDimensions.Y() ||
-         fDirection == kY && 
-        padDimensions.X() > 0. && padDimensions.X() < fMinPadDimensions.X())
+    if ( ( fDirection == AliMp::kX && dy > 0. && dy < fMinPadDimensionY ) ||
+         ( fDirection == AliMp::kY && dx > 0. && dx < fMinPadDimensionX ) ) {
       
-      fMinPadDimensions = padDimensions;
+      fMinPadDimensionX = dx;
+      fMinPadDimensionY = dy;
+    }  
+
+    if ( ( fDirection == AliMp::kX && dy > 0. && dy > fMaxPadDimensionY ) ||
+         ( fDirection == AliMp::kY && dx > 0. && dx > fMinPadDimensionX ) ) {
+      
+      fMaxPadDimensionX = dx;
+      fMaxPadDimensionY = dy;
+    }  
   }
 }
 
+//_____________________________________________________________________________
+void  AliMpSector::SetMaxPadIndices()
+{
+/// Set maximum pad indices in x, y
+
+  if ( fLMaxPadIndices != 0 ) return;
+  
+  Int_t maxIndexInX = 0;
+  Int_t maxIndexInY = 0;
+  for (Int_t i=0; i<GetNofRows(); i++) {
+
+    Int_t ixh = GetRow(i)->GetHighLimitIx();
+    if ( ixh > maxIndexInX ) maxIndexInX = ixh;
+
+    Int_t iyh = GetRow(i)->GetHighLimitIy();
+    if ( iyh > maxIndexInY ) maxIndexInY = iyh;
+  }  
+  
+  fLMaxPadIndices = AliMp::Pair(maxIndexInX, maxIndexInY);
+}
+
+
+//_____________________________________________________________________________
+void  AliMpSector::SetNofPads()
+{
+/// Set the total number of pads
+
+  fNofPads = fMotifMap->CalculateNofPads();
+}
+
+//_____________________________________________________________________________
+void  AliMpSector::SetDimensions()
+{
+/// Set the maximum halflengths in x, y.
+
+  fDimensionX = 0.;
+  fDimensionY = 0.;
+  
+  for (Int_t i=0; i<GetNofRows(); i++) {
+
+    // take the largest x row dimension
+    if ( ((AliMpRow*)fRows[i])->GetDimensionX() > fDimensionX ) 
+      fDimensionX = ((AliMpRow*)fRows[i])->GetDimensionX();
+      
+    // add all rows y dimensions  
+    fDimensionY += ((AliMpRow*)fRows[i])->GetDimensionY();
+  }
+}  
+
 //
 // public methods
 //
 
 //_____________________________________________________________________________
+AliMpVPadIterator* AliMpSector::CreateIterator() const
+{
+/// Create sector pad iterator
+
+  return new AliMpSectorPadIterator(this);
+}
+
+
+//_____________________________________________________________________________
 void  AliMpSector::SetRowSegmentOffsets()
 {
-// For all rows sets offset to all row segments.
-// ---
+/// For all rows set the offset to all row segments.
 
-  for (UInt_t irow=0; irow<fRows.size(); irow++)
-    GetRow(irow)->SetRowSegmentOffsets(fOffset);    
+  for (Int_t irow=0; irow<GetNofRows(); irow++)
+    GetRow(irow)->SetRowSegmentOffsets(fOffsetX);    
 }
 
 //_____________________________________________________________________________
 void AliMpSector::Initialize() 
 {
-// Makes needed settings after sector is read from
-// data files.
-// ---
+/// Make needed settings after sector is read from
+/// data files.
 
   SetRowOffsets();
   SetMotifPositions();
   SetGlobalIndices();
-  SetMinPadDimensions();
+  SetMinMaxPadDimensions();
+  SetMaxPadIndices();
+  SetNofPads();
+  SetDimensions();
 }  
 
 //_____________________________________________________________________________
 void AliMpSector::PrintGeometry()  const
 {
-// Prints the positions of rows, rows segments
-// ---
+/// Print the positions of rows, rows segments
 
   for (Int_t i=0; i<GetNofRows(); i++) {
     AliMpRow* row = GetRow(i);
     
     cout << "ROW " << row->GetID() 
-         << "  center Y " << row->Position().Y() << endl;
+         << "  center Y " << row->GetPositionY() << endl;
 
     for (Int_t j=0; j<row->GetNofRowSegments(); j++) {
        AliMpVRowSegment* rowSegment = row->GetRowSegment(j);
@@ -202,7 +334,7 @@ void AliMpSector::PrintGeometry()  const
             << rowSegment->LeftBorderX() << "  "
             << rowSegment->RightBorderX()
             << "  x-size " 
-            << 2*rowSegment->Dimensions().X() << "  "
+            << 2*rowSegment->GetDimensionX() << "  "
            << endl;
     }
   }
@@ -210,60 +342,10 @@ void AliMpSector::PrintGeometry()  const
             
 
 //_____________________________________________________________________________
-AliMpRow* AliMpSector::FindRow(const TVector2& position) const
-{
-// Finds the row for the specified y position.
-// If y is on border the lowest row is returned.
-// ---
-  
-  Double_t y = position.Y();
-  
-  for (UInt_t i=0; i<fRows.size(); i++) {
-    if ( y >= fRows[i]->LowBorderY() && y <= fRows[i]->UpperBorderY())
-      return fRows[i];
-  }    
-  
-  return 0;
-}
-
-//_____________________________________________________________________________
-AliMpVMotif* AliMpSector::FindMotif(const TVector2& position) const
-{
-// Finds the motif in the specified position.
-// Returns 0 if no motif is found.
-// ---
-  
-  // Find the row segment
-  AliMpVRowSegment* rowSegment = FindRowSegment(position);
-  
-  if (!rowSegment) return 0;
-  
-  // Find motif
-  return rowSegment->FindMotif(position);  
-}
-
-//_____________________________________________________________________________
-Int_t AliMpSector::FindMotifPositionId(const TVector2& position) const
-{
-// Finds the motif position ID in the specified position.
-// Returns 0 if no motif is found.
-// ---
-  
-  // Find the row segment
-  AliMpVRowSegment* rowSegment = FindRowSegment(position);
-  
-  if (!rowSegment) return 0;
-    
-  // Find motif position ID
-  return rowSegment->FindMotifPositionId(position);  
-}
-
-//_____________________________________________________________________________
 AliMpRow* AliMpSector::FindRow(Int_t motifPositionId) const
 {
-// Finds the row with the the specified motif position.
-// Returns 0 if no row is found.
-// ---
+/// Find the row with the the specified motif position.                     \n
+/// Return 0 if no row is found.
 
   AliMpVRowSegment* segment = FindRowSegment(motifPositionId);
   
@@ -275,13 +357,13 @@ AliMpRow* AliMpSector::FindRow(Int_t motifPositionId) const
 //_____________________________________________________________________________
 AliMpVRowSegment* AliMpSector::FindRowSegment(Int_t motifPositionId) const
 {
-// Finds the row segment with the the specified motif position.
-// Returns 0 if no row segment is found.
-// ---
+/// Find the row segment with the the specified motif position.            \n
+/// Return 0 if no row segment is found.
+
+  for (Int_t irow=0; irow<GetNofRows(); irow++) {
+
+    AliMpRow* row = (AliMpRow*)fRows[irow];
 
-  for (UInt_t irow=0; irow<fRows.size(); irow++) {
-    AliMpRow* row = fRows[irow];
-   
     for (Int_t iseg=0; iseg<row->GetNofRowSegments(); iseg++) {
       AliMpVRowSegment* segment = row->GetRowSegment(iseg); 
       if (segment->HasMotifPosition(motifPositionId)) return segment;
@@ -292,111 +374,113 @@ AliMpVRowSegment* AliMpSector::FindRowSegment(Int_t motifPositionId) const
 }
 
 //_____________________________________________________________________________
-TVector2  AliMpSector::FindPosition(Int_t motifPositionId) const
+Double_t AliMpSector::GetPositionX() const
 {
-// Finds the position of the motif specified by its position Id.
-// Returns 0 if no row segment is found.
-// ---
+/// Return the sector offset.
 
-  AliMpVRowSegment* segment = FindRowSegment(motifPositionId);
+  return fOffsetX;
+}  
 
-  if (!segment) {
-    Warning("FindPosition", "Given motifPositionId not found.");
-    return TVector2();
-  }   
 
-  return segment->MotifCenter(motifPositionId);
-}
-   
 //_____________________________________________________________________________
-AliMpZone*  AliMpSector::FindZone(const TVector2& padDimensions) const
+Double_t AliMpSector::GetPositionY() const
 {
-// Finds the zone with specified padDimensions.
-// ---
+/// Return the sector offset.
 
-  for (Int_t i=0; i<GetNofZones(); i++) {
-    AliMpZone* zone = GetZone(i+1);
-    if (AliMpConstants::IsEqual(padDimensions, zone->GetPadDimensions())) 
-      return zone;
-  }
-  
-  // Return 0 if not found
-  return 0;     
-}
+  return fOffsetY;
+}  
 
 //_____________________________________________________________________________
-TVector2 AliMpSector::Position() const
+Double_t  AliMpSector::GetDimensionX() const
 {
-// Returns the offset.
-// ---
+/// Return the maximum halflengths in x.
 
-  return fOffset;
+  return fDimensionX;
 }  
 
-
 //_____________________________________________________________________________
-TVector2 AliMpSector::Dimensions() const
+Double_t  AliMpSector::GetDimensionY() const
 {
-// Returns the maximum halflength in x, y.
-// ---
-
-  Double_t x = 0.;
-  Double_t y = 0.;
-  for (Int_t i=0; i<GetNofRows(); i++) {
+/// Return the maximum halflengths in y.
 
-    // take the largest x row dimension
-    if (fRows[i]->Dimensions().X() > x) 
-      x = fRows[i]->Dimensions().X();
-      
-    // add all rows y dimensions  
-    y += fRows[i]->Dimensions().Y();
-  }
-  
-  return TVector2(x, y);  
+  return fDimensionY;
 }  
 
 //_____________________________________________________________________________
 Int_t AliMpSector::GetNofZones() const
 {    
-// Returns the number of zones.
-// ---
+/// Return the number of zones.
 
-  return fZones.size();
+  return fZones.GetEntriesFast();
 }  
 
 //_____________________________________________________________________________
 AliMpZone* AliMpSector::GetZone(Int_t zoneID) const
 {
-// Returns zone with specified ID.
-// ---
+/// Return zone with specified ID.
 
   if (zoneID < 1 || zoneID > GetNofZones()) {
-    Warning("GetZone", "Index outside range");
+    AliWarningStream() << "Index outside range" << endl;
     return 0;
   }
   
-  return fZones[zoneID-1];
+  return (AliMpZone*)fZones[zoneID-1];
 }  
 
 //_____________________________________________________________________________
 Int_t AliMpSector::GetNofRows() const
 {
-// Returns the number of rows.
-// ---
+/// Return the number of rows.
 
-  return fRows.size();
+  return fRows.GetEntriesFast();
 }  
 
 //_____________________________________________________________________________
 AliMpRow* AliMpSector::GetRow(Int_t rowID) const
 {
-// Returns row with specified ID.
-// ---
+/// Return row with specified ID.
 
   if (rowID < 0 || rowID >= GetNofRows()) {
-    Warning("GetRow", "Index outside range");
+    AliWarningStream() << "Index outside range" << endl;
     return 0;
   }
   
-  return fRows[rowID];
+  return (AliMpRow*)fRows[rowID];
+}
+
+//_____________________________________________________________________________
+AliMp::PlaneType
+AliMpSector::GetPlaneType() const
+{
+/// Return the plane type
+
+  return GetDirection()==AliMp::kY ? AliMp::kBendingPlane : AliMp::kNonBendingPlane;
+}
+
+//_____________________________________________________________________________
+Int_t 
+AliMpSector::GetNofMotifPositions() const
+{
+  /// Return the number of manus
+  
+  return fMotifMap->GetNofMotifPositions();
+}
+
+//_____________________________________________________________________________
+void 
+AliMpSector::GetAllMotifPositionsIDs(TArrayI& ecn) const
+{
+/// Return the array of all motif positions IDs
+
+  fMotifMap->GetAllMotifPositionsIDs(ecn);
+}
+
+//_____________________________________________________________________________
+void
+AliMpSector::Print(Option_t* opt) const
+{
+/// Print the map of motifs
+
+  cout << "Sector," << PlaneTypeName(GetPlaneType()) << endl;
+  fMotifMap->Print(opt);
 }