AliMpRow.cxx

Go to the documentation of this file.

/**************************************************************************
 * 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: AliMpRow.cxx,v 1.9 2006/05/24 13:58:46 ivana Exp $
// Category: sector

//-----------------------------------------------------------------------------
// Class AliMpRow
// --------------
// Class describing a row composed of the row segments.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
//-----------------------------------------------------------------------------

#include "AliMpRow.h"
#include "AliMpVRowSegment.h"
#include "AliMpVRowSegmentSpecial.h"
#include "AliMpRowSegmentRSpecial.h"
#include "AliMpVMotif.h"
#include "AliMpMotifType.h"
#include "AliMpMotifPosition.h"
#include "AliMpMotifMap.h"
#include "AliMpConstants.h"

#include "AliLog.h"

#include <TMath.h>
#include <Riostream.h>

using std::endl;
ClassImp(AliMpRow)

//_____________________________________________________________________________
AliMpRow::AliMpRow(Int_t id, AliMpMotifMap* motifMap) 
  : AliMpVIndexed(),
    fID(id),
    fOffsetY(0.),
    fSegments(),
    fMotifMap(motifMap)
{
}

//_____________________________________________________________________________
AliMpRow::AliMpRow() 
  : AliMpVIndexed(),
    fID(0),
    fOffsetY(0.),
    fSegments(),
    fMotifMap(0)
{
}

//_____________________________________________________________________________
AliMpRow::~AliMpRow() 
{

  fSegments.Delete();
}

//
// private methods
//

//_____________________________________________________________________________
AliMpVRowSegment*  AliMpRow::FindRowSegment(Int_t ix) const
{    

  for (Int_t i=0; i<GetNofRowSegments(); i++) {
    AliMpVRowSegment* segment = GetRowSegment(i);

    if (!dynamic_cast<AliMpVRowSegmentSpecial*>(segment) &&
         segment->GetHighLimitIx() >= ix)
   
     return segment;   
  }   

  return 0;  
}

//_____________________________________________________________________________
AliMpMotifPosition*  
AliMpRow::FindMotifPosition(AliMpVRowSegment* segment, Int_t ix) const
{

  if (!segment) return 0;

  for (Int_t i=0; i<segment->GetNofMotifs(); i++){
     AliMpMotifPosition* motifPosition 
       = GetMotifMap()->FindMotifPosition(segment->GetMotifPositionId(i));
       
     if(!motifPosition) {
       Fatal("FindMotifPosition", "Not found.");
       return 0;
     }  
     
     if (motifPosition->GetHighLimitIx()>=ix) 
       return motifPosition;
  }
  
  return 0;     
}


//_____________________________________________________________________________
void AliMpRow::SetHighIndicesLimits(Int_t iy)
{

  for (Int_t j=0; j<GetNofRowSegments(); j++) {
     AliMpVRowSegment* rowSegment = GetRowSegment(j);       
     rowSegment
       ->SetHighIndicesLimit(rowSegment->GetHighLimitIx(),iy);

    for (Int_t k=0; k<rowSegment->GetNofMotifs(); k++) {

      Int_t motifPositionId = rowSegment->GetMotifPositionId(k);
      AliMpMotifPosition* motifPosition 
  = GetMotifMap()->FindMotifPosition(motifPositionId);

      motifPosition
  ->SetHighIndicesLimit(motifPosition->GetHighLimitIx(), iy);
     
    }
  }  
}

//_____________________________________________________________________________
void  AliMpRow::CheckEmpty() const
{

  if (GetNofRowSegments() == 0) 
    Fatal("CheckEmpty", "Empty row");
}

//
// public methods
//

//_____________________________________________________________________________
void AliMpRow::AddRowSegment(AliMpVRowSegment* rowSegment)
{

  fSegments.Add(rowSegment);
}  
  
//_____________________________________________________________________________
void AliMpRow::AddRowSegmentInFront(AliMpVRowSegment* rowSegment)
{

  fSegments.AddFirst(rowSegment);
}  
  
//_____________________________________________________________________________
AliMpVRowSegment* AliMpRow::FindRowSegment(Double_t x) const
{

  for (Int_t i=0; i<GetNofRowSegments(); i++) {

    AliMpVRowSegment* rs = (AliMpVRowSegment*)fSegments.At(i);

    if (x >= rs->LeftBorderX() && x <= rs->RightBorderX())
      return rs;
  }
  
  return 0;    
}    

//_____________________________________________________________________________
Double_t AliMpRow::LowBorderY() const
{

  CheckEmpty();

  return fOffsetY - GetRowSegment(0)->HalfSizeY();
}  

//_____________________________________________________________________________
Double_t AliMpRow::UpperBorderY() const
{
\
  CheckEmpty();

  return fOffsetY + GetRowSegment(0)->HalfSizeY();
}  

//_____________________________________________________________________________
AliMpVPadIterator* AliMpRow::CreateIterator() const
{

  Fatal("CreateIterator", "Iterator is not implemented.");
  
  return 0;
}  

//_____________________________________________________________________________
void AliMpRow::SetMotifPositions()
{

  CheckEmpty();

  for (Int_t j=0; j<GetNofRowSegments(); j++) {
     AliMpVRowSegment* rowSegment = GetRowSegment(j);

     for (Int_t k=0; k<rowSegment->GetNofMotifs(); k++) {
        // Get values 
  Int_t motifPositionId = rowSegment->GetMotifPositionId(k);
  AliMpVMotif* motif = rowSegment->GetMotif(k);
        
        Double_t posx, posy;
  rowSegment->MotifCenter(motifPositionId, posx, posy);
       
        AliMpMotifPosition* motifPosition 
    = new AliMpMotifPosition(motifPositionId, motif, posx, posy);

        // set the initial value to of HighIndicesLimit() Invalid()
        // (this is used for calculation of indices in case of
        // special row segments)
        motifPosition->SetHighIndicesLimit(0, 0, false);

        //Bool_t warn = (rowSegment->GetNofMotifs()==1); 
        Bool_t warn = true;
  if (dynamic_cast<AliMpVRowSegmentSpecial*>(rowSegment)) warn = false; 
               // supress warnings for special row segments
         // which motifs can overlap the row borders
         
        Bool_t added = GetMotifMap()->AddMotifPosition(motifPosition, warn);
  
  if (!added) delete motifPosition; 
     }  
  }
}    

//_____________________________________________________________________________
void AliMpRow::SetGlobalIndices(AliMp::Direction constPadSizeDirection, 
                                AliMpRow* rowBefore)
{

  Int_t ix = AliMpConstants::StartPadIndex();
  Int_t iy = AliMpConstants::StartPadIndex();

  for (Int_t j=0; j<GetNofRowSegments(); j++) {
     AliMpVRowSegment* rowSegment = GetRowSegment(j);
     
     ix += rowSegment->GetLowLimitIx();

     for (Int_t k=0; k<rowSegment->GetNofMotifs(); k++) {
     
       // Find the y index value of the low edge
       if (rowBefore) {
         if (constPadSizeDirection == AliMp::kY) {
           iy = rowBefore->GetHighLimitIy()+1;
         } 
   else {
           AliMpVRowSegment* seg = rowBefore->FindRowSegment(ix); 
     AliMpMotifPosition* motPos =  FindMotifPosition(seg, ix);
     if (!dynamic_cast<AliMpRowSegmentRSpecial*>(rowSegment)) {
             if (!motPos) {
         Fatal("SetGlobalIndices", "Motif position in rowBefore not found.");
               return;
             }  
     
             iy = motPos->GetHighLimitIy()+1;
     }  
         }
       } 

       // Set (ix, iy) to k-th motif position and update ix
       ix = rowSegment->SetIndicesToMotifPosition(k, AliMp::Pair(ix, iy));
    }
    rowSegment->SetGlobalIndices(rowBefore);    
  }

  // The low/high indices limits has to be taken as the highest/lowest from all 
  // row segments
  Int_t ixl = 9999;
  Int_t iyl = 9999;
  Int_t ixh = AliMpConstants::StartPadIndex();
  Int_t iyh = AliMpConstants::StartPadIndex();

  for (Int_t i=0; i<GetNofRowSegments(); i++) {
    
    AliMpVRowSegment* rowSegment = GetRowSegment(i);
    
    if ( rowSegment->GetLowLimitIx() < ixl ) 
       ixl = rowSegment->GetLowLimitIx();
       
    if ( rowSegment->GetLowLimitIy() < iyl ) 
       iyl = rowSegment->GetLowLimitIy();

    if ( rowSegment->GetHighLimitIx() > ixh ) 
       ixh = rowSegment->GetHighLimitIx();
       
    if ( rowSegment->GetHighLimitIy() > iyh ) 
       iyh = rowSegment->GetHighLimitIy();
  }     

  SetLowIndicesLimit(ixl, iyl);
  SetHighIndicesLimit(ixh, iyh);
}

//_____________________________________________________________________________
Double_t  AliMpRow::GetPositionX() const
{

  return ( GetRowSegment(0)->LeftBorderX() +
           GetRowSegment(GetNofRowSegments()-1)->RightBorderX() )/2.;
}

//_____________________________________________________________________________
Double_t  AliMpRow::GetPositionY() const
{

  return fOffsetY;  
}

//_____________________________________________________________________________
Double_t  AliMpRow::GetDimensionX() const
{

  return ( GetRowSegment(GetNofRowSegments()-1)->RightBorderX() -
           GetRowSegment(0)->LeftBorderX() )/2.;
}

//_____________________________________________________________________________
Double_t  AliMpRow::GetDimensionY() const
{

  return GetRowSegment(0)->HalfSizeY();  
}

//_____________________________________________________________________________
void AliMpRow::SetRowSegmentOffsets(Double_t offsetx)
{

  CheckEmpty();
  
  AliMpVRowSegment* previous = 0;

  for (Int_t j=0; j<GetNofRowSegments(); j++) {
     AliMpVRowSegment* rowSegment = GetRowSegment(j);

     Double_t offsetX;
     if (previous) 
      offsetX = previous->RightBorderX();
    else
      offsetX = offsetx;  
  
    rowSegment->SetOffset(offsetX, 0.);
    previous = rowSegment;  
  }
}


//_____________________________________________________________________________
Double_t AliMpRow::SetOffsetY(Double_t offsetY)
{

  CheckEmpty();

  AliMpVRowSegment* first = GetRowSegment(0);
  Double_t rowSizeY = first->HalfSizeY();
  
  // Check if all next row segments have motif of
  // the same size in y
  for (Int_t i=1; i<GetNofRowSegments(); i++) {
     Double_t sizeY = GetRowSegment(i)->HalfSizeY();
     
     if (TMath::Abs(sizeY - rowSizeY) >= AliMpConstants::LengthTolerance()) {
       Fatal("SetOffsetY", "Motif with different Y size in one row");
       return 0.;
     }  
  }

  offsetY += rowSizeY ;
    
  fOffsetY = offsetY;
    
  return offsetY += rowSizeY;
}  

//_____________________________________________________________________________
Int_t AliMpRow::GetNofRowSegments() const 
{

  return fSegments.GetSize();
}  

//_____________________________________________________________________________
AliMpVRowSegment* AliMpRow::GetRowSegment(Int_t i) const 
{

  if (i<0 || i>=GetNofRowSegments()) {
    AliWarningStream() << "Index outside range" << endl;
    return 0;
  }
  
  return (AliMpVRowSegment*)fSegments.At(i);  
}