[u/mrichter/AliRoot.git] / MUON / mapping / AliMpMotifType.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$
// $MpId: AliMpMotifType.cxx,v 1.10 2006/05/24 13:58:41 ivana Exp $
// Category: motif

//-----------------------------------------------------------------------------
// Class AliMpMotifType
// --------------------
// Class that defines the motif properties.
// Included in AliRoot: 2003/05/02
// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
//-----------------------------------------------------------------------------

#include "AliMpMotifType.h"
#include "AliMpExMapIterator.h"
#include "AliMpMotifTypePadIterator.h"
#include "AliMpConnection.h"
#include "AliMpConstants.h"
#include "AliMpFiles.h"
#include "AliMpEncodePair.h"

#include "AliLog.h"

#include <TSystem.h>
#include <Riostream.h>

#include <cstdlib>

using std::cout;
using std::endl;
using std::ofstream;
using std::setw;
/// \cond CLASSIMP
ClassImp(AliMpMotifType)
/// \endcond

const Int_t AliMpMotifType::fgkPadNumForA = 65;

//______________________________________________________________________________
AliMpMotifType::AliMpMotifType(const TString &id) 
: TObject(),
fID(id),
fNofPadsX(0),   
fNofPadsY(0),
fNofPads(0),
fMaxNofPads(AliMpConstants::ManuNofChannels()),
fConnectionsByLocalIndices(fMaxNofPads*fMaxNofPads),
fConnectionsByManuChannel(fMaxNofPads)
{
  /// Standard constructor                                                   \n
  /// Please note that id should be of the form %s for station 1,2,
  //  %s-%e-%e for station345 and %sx%e for stationTrigger

  fConnectionsByLocalIndices.SetOwner(kTRUE);
  fConnectionsByManuChannel.SetOwner(kFALSE);
  AliDebug(1,Form("this=%p id=%s",this,id.Data()));
}

//______________________________________________________________________________
AliMpMotifType::AliMpMotifType(TRootIOCtor*) 
: TObject(),
fID(""),
fNofPadsX(0),   
fNofPadsY(0),
fNofPads(0),
fMaxNofPads(0),
fConnectionsByLocalIndices(),
fConnectionsByManuChannel()
{
  /// Default constructor
  AliDebug(1,Form("this=%p",this));
}

//______________________________________________________________________________
AliMpMotifType::AliMpMotifType(const AliMpMotifType& rhs)
: TObject(),
fID(""),
fNofPadsX(0),   
fNofPadsY(0),
fNofPads(0),
fMaxNofPads(0),
fConnectionsByLocalIndices(),
fConnectionsByManuChannel()
{
  /// Copy constructor
  AliDebug(1,Form("this=%p (copy ctor)",this));
  rhs.Copy(*this);
}

//______________________________________________________________________________
AliMpMotifType&
AliMpMotifType::operator=(const AliMpMotifType& rhs)
{
  /// Assignment operator
  
  TObject::operator=(rhs);
  rhs.Copy(*this);
  return *this;  
}

//______________________________________________________________________________
TObject*
AliMpMotifType::Clone(const char* /*newname*/) const 
{
  /// Returns a full copy of this object
  return new AliMpMotifType(*this);
}

//______________________________________________________________________________
void
AliMpMotifType::Copy(TObject& object) const
{
  /// Copy object

  TObject::Copy(object);
  AliMpMotifType& mt = static_cast<AliMpMotifType&>(object);
  mt.fID = fID;
  mt.fNofPadsX = fNofPadsX;
  mt.fNofPadsY = fNofPadsY;
  mt.fNofPads = fNofPads;
  mt.fMaxNofPads = fMaxNofPads;
  mt.fConnectionsByLocalIndices = fConnectionsByLocalIndices;
  mt.fConnectionsByManuChannel = fConnectionsByManuChannel;  
}

//______________________________________________________________________________
AliMpMotifType::~AliMpMotifType() 
{
  /// Destructor

  AliDebug(1,Form("this=%p",this));
}

//______________________________________________________________________________
AliMpVPadIterator* AliMpMotifType::CreateIterator() const
{
/// Create new motif type iterator

  return new AliMpMotifTypePadIterator(this);
}

//______________________________________________________________________________
void AliMpMotifType::SetNofPads(Int_t nofPadsX, Int_t nofPadsY)
{
  /// Change the number of pads in this motif

  fNofPadsX = nofPadsX;
  fNofPadsY = nofPadsY;
}


//______________________________________________________________________________
Int_t AliMpMotifType::PadNum(const TString &padName) const
{
  /// Transform a pad name into the equivalent pad number

  if ( (padName[0]>='A') && (padName[0]<='Z') )
    return fgkPadNumForA+padName[0]-'A';
  else
    return atoi(padName.Data());
}

//______________________________________________________________________________
TString AliMpMotifType::PadName(Int_t padNum) const
{
  /// Transform a pad number into its equivalent pad name

  if (padNum<fgkPadNumForA)
    return Form("%d",padNum);
  else
    return char('A'+padNum-fgkPadNumForA);
}

//______________________________________________________________________________
Bool_t 
AliMpMotifType::AddConnection(AliMpConnection* connection)
{
  /// Add the connection to the map
  
  if (!connection) return kFALSE;
  
  Int_t ix = connection->GetLocalIx();
  Int_t iy = connection->GetLocalIy();
  
  Int_t manuChannel = connection->GetManuChannel();
  
  if ( ix >=0 && ix < fMaxNofPads &&
      iy >=0 && iy < fMaxNofPads && 
      manuChannel >= 0 && manuChannel < AliMpConstants::ManuNofChannels())
  {
  
    Int_t index = ix + iy*AliMpConstants::ManuNofChannels();
    
    AliMpConnection* c = FindConnectionByLocalIndices(
                             connection->GetLocalIndices());
    
    if (c)
    {
      AliError(Form("Connection already exists for ix=%d iy=%d",ix,iy));
      return kFALSE;
    }
    
    ++fNofPads;

    fConnectionsByLocalIndices[index] = connection;
    fConnectionsByManuChannel[manuChannel] = connection;
    
    connection->SetOwner(this);
    
    return kTRUE;
  
  }
  return kFALSE;
}  

//______________________________________________________________________________
AliMpConnection*
AliMpMotifType::FindConnectionByPadNum(Int_t padNum) const
{
  /// Retrieve the AliMpConnection pointer from its pad num
  /// This method is quite inefficient as we're looping over all connections
  
  TIter next(&fConnectionsByManuChannel);
  AliMpConnection* connection;
  
  while ( ( connection = static_cast<AliMpConnection*>(next()) ) )
  {
    if (connection->GetPadNum()==padNum) return connection;
  }    
  return 0x0;
}

//______________________________________________________________________________
AliMpConnection*
AliMpMotifType::FindConnectionByLocalIndices(MpPair_t localIndices) const
{
  /// Retrieve the AliMpConnection pointer from its position (in pad unit)

  return FindConnectionByLocalIndices(AliMp::PairFirst(localIndices),
                                      AliMp::PairSecond(localIndices));
}

//______________________________________________________________________________
AliMpConnection*
AliMpMotifType::FindConnectionByLocalIndices(Int_t ix, Int_t iy) const
{
  /// Retrieve the AliMpConnection pointer from its position (in pad unit)

  if ( ix < fNofPadsX && iy < fNofPadsY && ix >= 0 && iy >= 0 )
  {  
    Int_t index = ix + iy*fMaxNofPads;

    return static_cast<AliMpConnection*>(fConnectionsByLocalIndices.UncheckedAt(index));
  }
  else
  {
    return 0x0;
  }
}

//______________________________________________________________________________
AliMpConnection*
AliMpMotifType::FindConnectionByGassiNum(Int_t gassiNum) const
{
  /// Return the connection for the given gassiplex number
  
  if ( gassiNum >=0 && gassiNum < fMaxNofPads ) 
  {
    return static_cast<AliMpConnection*>(fConnectionsByManuChannel.UncheckedAt(gassiNum));
  }
  
  return 0x0;
}

//______________________________________________________________________________
AliMpConnection*
AliMpMotifType::FindConnectionByKaptonNum(Int_t kaptonNum) const
{
  /// Give the connection related to the given kapton number
  /// Inefficient method as we loop over connections to find the right one
  
  TIter next(&fConnectionsByManuChannel);
  AliMpConnection* connection;
  
  while ( ( connection = static_cast<AliMpConnection*>(next()) ) )
  {
    if ( connection && connection->GetKaptonNum()==kaptonNum) return connection;
  }
  return 0x0;
}

//______________________________________________________________________________
AliMpConnection*
AliMpMotifType::FindConnectionByBergNum(Int_t bergNum) const
{
  /// Retrieve the connection from a Berg connector number
  /// Inefficient method as we loop over connections to find the right one
  
  TIter next(&fConnectionsByManuChannel);
  AliMpConnection* connection;
  
  while ( ( connection = static_cast<AliMpConnection*>(next()) ) )
  {
    if ( connection && connection->GetBergNum()==bergNum) return connection;
  }
  return 0x0;
}


//______________________________________________________________________________
MpPair_t AliMpMotifType::FindLocalIndicesByConnection(const AliMpConnection* connection) const
{
  /// Reurn the pad position from the connection pointer.

  return connection->GetLocalIndices();
}

//______________________________________________________________________________
MpPair_t AliMpMotifType::FindLocalIndicesByPadNum(Int_t padNum) const
{
  /// Retrieve the AliMpConnection pointer from its pad num
  
  AliMpConnection* connection = FindConnectionByPadNum(padNum);
  
  if ( ! connection) return -1;
  
  return connection->GetLocalIndices();
}

//______________________________________________________________________________
MpPair_t AliMpMotifType::FindLocalIndicesByGassiNum(Int_t gassiNum) const
{
  /// Return the connection for the given gassiplex number
  
  AliMpConnection* connection = FindConnectionByGassiNum(gassiNum);
  
  if ( ! connection) return -1;

  return connection->GetLocalIndices();
}

//______________________________________________________________________________
MpPair_t AliMpMotifType::FindLocalIndicesByKaptonNum(Int_t kaptonNum) const
{
  /// Give the connection related to the given kapton number

  AliMpConnection* connection = FindConnectionByKaptonNum(kaptonNum);
  
  if ( ! connection) return -1;

  return connection->GetLocalIndices();
}

//______________________________________________________________________________
MpPair_t AliMpMotifType::FindLocalIndicesByBergNum(Int_t bergNum) const
{
  /// Retrieve the connection from a Berg connector number
  
  AliMpConnection* connection = FindConnectionByBergNum(bergNum);
  
  if ( ! connection) return -1;

  return connection->GetLocalIndices();
}

//______________________________________________________________________________
Bool_t 
AliMpMotifType::HasPadByLocalIndices(MpPair_t localIndices) const
{
  /// Return true if the pad indexed by \a localIndices has a connection
    
  return ( FindConnectionByLocalIndices(localIndices) != 0x0 );
}

//______________________________________________________________________________
Bool_t 
AliMpMotifType::HasPadByLocalIndices(Int_t localIx, Int_t localIy) const
{
  /// Return true if the pad indexed by \a localIndices has a connection
    
  return ( FindConnectionByLocalIndices(localIx, localIy) != 0x0 );
}

//______________________________________________________________________________
Bool_t 
AliMpMotifType::HasPadByManuChannel(Int_t manuChannel) const
{
  /// Return true if the pad indexed by \a localIndices has a connection
  
//  if ( manuChannel >= fNofPads ) return kFALSE;
  
  return ( FindConnectionByGassiNum(manuChannel) != 0x0 );
}

//______________________________________________________________________________
void AliMpMotifType::Print(Option_t *option) const
{
  /// Print the map of the motif. In each cell, the value
  /// printed depends of option, as the following:
  /// - option="N" the "name" of the pad is written
  /// - option="K" the Kapton connect. number attached to the pad is written
  /// - option="B" the Berg connect. number attached to the pad is written
  /// - option="G" the Gassiplex channel number attached to the pad is written
  /// otherwise the number of the pad is written
  ///
  /// NOTE : this method is really not optimized, in case 'N' or '',
  /// but the Print() this should not be very important in a Print() method

  switch (option[0]){
  case 'N':cout<<"Name mapping";
    break;
  case 'K':cout<<"Kapton mapping";
    break;
  case 'B':cout<<"Berg mapping";
    break;
  case 'G':cout<<"Gassiplex number mapping";
    break;
  default:cout<<"Pad mapping";
  }
  cout<<" in the motif "<<fID<<endl;
  cout<<"-----------------------------------"<<endl;

  for (Int_t j=fNofPadsY-1;j>=0;j--){
    for (Int_t i=0;i<fNofPadsX;i++){
      AliMpConnection *connexion = FindConnectionByLocalIndices(i,j);
      TString str;
      if (connexion){
        AliDebug(1,Form("i,j=%2d,%2d connexion=%p",i,j,connexion));
        
        switch (option[0]){
          case 'N':str=PadName(connexion->GetPadNum());
            break;
          case 'K':str=Form("%d",connexion->GetKaptonNum());
            break;
          case 'B':str=Form("%d",connexion->GetBergNum());
            break;
          case 'G':str=Form("%d",connexion->GetManuChannel());
            break;
          default:str= Form("%d",connexion->GetPadNum());
        }
        cout<<setw(2)<<str;
      } else cout<<setw(2)<<"--";
      cout<<" ";
    }
    cout<<endl;
  }
}

//_____________________________________________________________________________
Bool_t
AliMpMotifType::Save() const
{
/// Save this motif type

  return Save(fID.Data());
}

//_____________________________________________________________________________
Bool_t
AliMpMotifType::Save(const char* motifName) const
{
  /// Generate the 2 files needed to describe the motif
  
  TString padPosFileName(AliMpFiles::PadPosFileName(motifName));
  
  TString motifTypeFileName(AliMpFiles::MotifFileName(motifName));

  // first a protection : do not allow overwriting existing files...
  Bool_t test = gSystem->AccessPathName(padPosFileName.Data());
  if (test==kFALSE) // AccessPathName has a strange return value convention...
  {
    AliError("Cannot overwrite existing padPos file");
    return kFALSE;
  }
  test = gSystem->AccessPathName(motifTypeFileName.Data());
  if (test==kFALSE)
  {
    AliError("Cannot overwrite existing motifType file");
    return kFALSE;    
  }
  
  ofstream padPosFile(padPosFileName.Data());
  ofstream motifFile(motifTypeFileName.Data());
  
  motifFile <<  "# Motif " << motifName << endl
    << "#" << endl
    << "#connecteur_berg kapton padname not_used" << endl
    << "#for slats there's no kapton connector, so it's always 1" 
    << " (zero make the reader" << endl
    << "#exit, so it's not a valid value here)." << endl
    << "#" << endl;
  
  for ( Int_t ix = 0; ix < GetNofPadsX(); ++ix ) 
  {
    for ( Int_t iy = 0; iy < GetNofPadsY(); ++iy ) 
    {
      AliMpConnection* con = FindConnectionByLocalIndices(ix,iy);
      if (con)
      {
        motifFile << con->GetBergNum() << "\t1\t" << con->GetPadNum() << "\t-" << endl;
        padPosFile << con->GetPadNum() << "\t" << ix << "\t" << iy << endl;
      }
    }
  }
  
  padPosFile.close();
  motifFile.close();
  
  return kTRUE;
}
Commit	Line	Data
	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: AliMpMotifType.cxx,v 1.10 2006/05/24 13:58:41 ivana Exp $
	18	// Category: motif
	19
	20	//-----------------------------------------------------------------------------
	21	// Class AliMpMotifType
	22	// --------------------
	23	// Class that defines the motif properties.
	24	// Included in AliRoot: 2003/05/02
	25	// Authors: David Guez, Ivana Hrivnacova; IPN Orsay
	26	//-----------------------------------------------------------------------------
	27
	28	#include "AliMpMotifType.h"
	29	#include "AliMpExMapIterator.h"
	30	#include "AliMpMotifTypePadIterator.h"
	31	#include "AliMpConnection.h"
	32	#include "AliMpConstants.h"
	33	#include "AliMpFiles.h"
	34	#include "AliMpEncodePair.h"
	35
	36	#include "AliLog.h"
	37
	38	#include <TSystem.h>
	39	#include <Riostream.h>
	40
	41	#include <cstdlib>
	42
	43	using std::cout;
	44	using std::endl;
	45	using std::ofstream;
	46	using std::setw;
	47	/// \cond CLASSIMP
	48	ClassImp(AliMpMotifType)
	49	/// \endcond
	50
	51	const Int_t AliMpMotifType::fgkPadNumForA = 65;
	52
	53	//______________________________________________________________________________
	54	AliMpMotifType::AliMpMotifType(const TString &id)
	55	: TObject(),
	56	fID(id),
	57	fNofPadsX(0),
	58	fNofPadsY(0),
	59	fNofPads(0),
	60	fMaxNofPads(AliMpConstants::ManuNofChannels()),
	61	fConnectionsByLocalIndices(fMaxNofPads*fMaxNofPads),
	62	fConnectionsByManuChannel(fMaxNofPads)
	63	{
	64	/// Standard constructor \n
	65	/// Please note that id should be of the form %s for station 1,2,
	66	// %s-%e-%e for station345 and %sx%e for stationTrigger
	67
	68	fConnectionsByLocalIndices.SetOwner(kTRUE);
	69	fConnectionsByManuChannel.SetOwner(kFALSE);
	70	AliDebug(1,Form("this=%p id=%s",this,id.Data()));
	71	}
	72
	73	//______________________________________________________________________________
	74	AliMpMotifType::AliMpMotifType(TRootIOCtor*)
	75	: TObject(),
	76	fID(""),
	77	fNofPadsX(0),
	78	fNofPadsY(0),
	79	fNofPads(0),
	80	fMaxNofPads(0),
	81	fConnectionsByLocalIndices(),
	82	fConnectionsByManuChannel()
	83	{
	84	/// Default constructor
	85	AliDebug(1,Form("this=%p",this));
	86	}
	87
	88	//______________________________________________________________________________
	89	AliMpMotifType::AliMpMotifType(const AliMpMotifType& rhs)
	90	: TObject(),
	91	fID(""),
	92	fNofPadsX(0),
	93	fNofPadsY(0),
	94	fNofPads(0),
	95	fMaxNofPads(0),
	96	fConnectionsByLocalIndices(),
	97	fConnectionsByManuChannel()
	98	{
	99	/// Copy constructor
	100	AliDebug(1,Form("this=%p (copy ctor)",this));
	101	rhs.Copy(*this);
	102	}
	103
	104	//______________________________________________________________________________
	105	AliMpMotifType&
	106	AliMpMotifType::operator=(const AliMpMotifType& rhs)
	107	{
	108	/// Assignment operator
	109
	110	TObject::operator=(rhs);
	111	rhs.Copy(*this);
	112	return *this;
	113	}
	114
	115	//______________________________________________________________________________
	116	TObject*
	117	AliMpMotifType::Clone(const char* /newname/) const
	118	{
	119	/// Returns a full copy of this object
	120	return new AliMpMotifType(*this);
	121	}
	122
	123	//______________________________________________________________________________
	124	void
	125	AliMpMotifType::Copy(TObject& object) const
	126	{
	127	/// Copy object
	128
	129	TObject::Copy(object);
	130	AliMpMotifType& mt = static_cast<AliMpMotifType&>(object);
	131	mt.fID = fID;
	132	mt.fNofPadsX = fNofPadsX;
	133	mt.fNofPadsY = fNofPadsY;
	134	mt.fNofPads = fNofPads;
	135	mt.fMaxNofPads = fMaxNofPads;
	136	mt.fConnectionsByLocalIndices = fConnectionsByLocalIndices;
	137	mt.fConnectionsByManuChannel = fConnectionsByManuChannel;
	138	}
	139
	140	//______________________________________________________________________________
	141	AliMpMotifType::~AliMpMotifType()
	142	{
	143	/// Destructor
	144
	145	AliDebug(1,Form("this=%p",this));
	146	}
	147
	148	//______________________________________________________________________________
	149	AliMpVPadIterator* AliMpMotifType::CreateIterator() const
	150	{
	151	/// Create new motif type iterator
	152
	153	return new AliMpMotifTypePadIterator(this);
	154	}
	155
	156	//______________________________________________________________________________
	157	void AliMpMotifType::SetNofPads(Int_t nofPadsX, Int_t nofPadsY)
	158	{
	159	/// Change the number of pads in this motif
	160
	161	fNofPadsX = nofPadsX;
	162	fNofPadsY = nofPadsY;
	163	}
	164
	165
	166	//______________________________________________________________________________
	167	Int_t AliMpMotifType::PadNum(const TString &padName) const
	168	{
	169	/// Transform a pad name into the equivalent pad number
	170
	171	if ( (padName[0]>='A') && (padName[0]<='Z') )
	172	return fgkPadNumForA+padName[0]-'A';
	173	else
	174	return atoi(padName.Data());
	175	}
	176
	177	//______________________________________________________________________________
	178	TString AliMpMotifType::PadName(Int_t padNum) const
	179	{
	180	/// Transform a pad number into its equivalent pad name
	181
	182	if (padNum<fgkPadNumForA)
	183	return Form("%d",padNum);
	184	else
	185	return char('A'+padNum-fgkPadNumForA);
	186	}
	187
	188	//______________________________________________________________________________
	189	Bool_t
	190	AliMpMotifType::AddConnection(AliMpConnection* connection)
	191	{
	192	/// Add the connection to the map
	193
	194	if (!connection) return kFALSE;
	195
	196	Int_t ix = connection->GetLocalIx();
	197	Int_t iy = connection->GetLocalIy();
	198
	199	Int_t manuChannel = connection->GetManuChannel();
	200
	201	if ( ix >=0 && ix < fMaxNofPads &&
	202	iy >=0 && iy < fMaxNofPads &&
	203	manuChannel >= 0 && manuChannel < AliMpConstants::ManuNofChannels())
	204	{
	205
	206	Int_t index = ix + iy*AliMpConstants::ManuNofChannels();
	207
	208	AliMpConnection* c = FindConnectionByLocalIndices(
	209	connection->GetLocalIndices());
	210
	211	if (c)
	212	{
	213	AliError(Form("Connection already exists for ix=%d iy=%d",ix,iy));
	214	return kFALSE;
	215	}
	216
	217	++fNofPads;
	218
	219	fConnectionsByLocalIndices[index] = connection;
	220	fConnectionsByManuChannel[manuChannel] = connection;
	221
	222	connection->SetOwner(this);
	223
	224	return kTRUE;
	225
	226	}
	227	return kFALSE;
	228	}
	229
	230	//______________________________________________________________________________
	231	AliMpConnection*
	232	AliMpMotifType::FindConnectionByPadNum(Int_t padNum) const
	233	{
	234	/// Retrieve the AliMpConnection pointer from its pad num
	235	/// This method is quite inefficient as we're looping over all connections
	236
	237	TIter next(&fConnectionsByManuChannel);
	238	AliMpConnection* connection;
	239
	240	while ( ( connection = static_cast<AliMpConnection*>(next()) ) )
	241	{
	242	if (connection->GetPadNum()==padNum) return connection;
	243	}
	244	return 0x0;
	245	}
	246
	247	//______________________________________________________________________________
	248	AliMpConnection*
	249	AliMpMotifType::FindConnectionByLocalIndices(MpPair_t localIndices) const
	250	{
	251	/// Retrieve the AliMpConnection pointer from its position (in pad unit)
	252
	253	return FindConnectionByLocalIndices(AliMp::PairFirst(localIndices),
	254	AliMp::PairSecond(localIndices));
	255	}
	256
	257	//______________________________________________________________________________
	258	AliMpConnection*
	259	AliMpMotifType::FindConnectionByLocalIndices(Int_t ix, Int_t iy) const
	260	{
	261	/// Retrieve the AliMpConnection pointer from its position (in pad unit)
	262
	263	if ( ix < fNofPadsX && iy < fNofPadsY && ix >= 0 && iy >= 0 )
	264	{
	265	Int_t index = ix + iy*fMaxNofPads;
	266
	267	return static_cast<AliMpConnection*>(fConnectionsByLocalIndices.UncheckedAt(index));
	268	}
	269	else
	270	{
	271	return 0x0;
	272	}
	273	}
	274
	275	//______________________________________________________________________________
	276	AliMpConnection*
	277	AliMpMotifType::FindConnectionByGassiNum(Int_t gassiNum) const
	278	{
	279	/// Return the connection for the given gassiplex number
	280
	281	if ( gassiNum >=0 && gassiNum < fMaxNofPads )
	282	{
	283	return static_cast<AliMpConnection*>(fConnectionsByManuChannel.UncheckedAt(gassiNum));
	284	}
	285
	286	return 0x0;
	287	}
	288
	289	//______________________________________________________________________________
	290	AliMpConnection*
	291	AliMpMotifType::FindConnectionByKaptonNum(Int_t kaptonNum) const
	292	{
	293	/// Give the connection related to the given kapton number
	294	/// Inefficient method as we loop over connections to find the right one
	295
	296	TIter next(&fConnectionsByManuChannel);
	297	AliMpConnection* connection;
	298
	299	while ( ( connection = static_cast<AliMpConnection*>(next()) ) )
	300	{
	301	if ( connection && connection->GetKaptonNum()==kaptonNum) return connection;
	302	}
	303	return 0x0;
	304	}
	305
	306	//______________________________________________________________________________
	307	AliMpConnection*
	308	AliMpMotifType::FindConnectionByBergNum(Int_t bergNum) const
	309	{
	310	/// Retrieve the connection from a Berg connector number
	311	/// Inefficient method as we loop over connections to find the right one
	312
	313	TIter next(&fConnectionsByManuChannel);
	314	AliMpConnection* connection;
	315
	316	while ( ( connection = static_cast<AliMpConnection*>(next()) ) )
	317	{
	318	if ( connection && connection->GetBergNum()==bergNum) return connection;
	319	}
	320	return 0x0;
	321	}
	322
	323
	324	//______________________________________________________________________________
	325	MpPair_t AliMpMotifType::FindLocalIndicesByConnection(const AliMpConnection* connection) const
	326	{
	327	/// Reurn the pad position from the connection pointer.
	328
	329	return connection->GetLocalIndices();
	330	}
	331
	332	//______________________________________________________________________________
	333	MpPair_t AliMpMotifType::FindLocalIndicesByPadNum(Int_t padNum) const
	334	{
	335	/// Retrieve the AliMpConnection pointer from its pad num
	336
	337	AliMpConnection* connection = FindConnectionByPadNum(padNum);
	338
	339	if ( ! connection) return -1;
	340
	341	return connection->GetLocalIndices();
	342	}
	343
	344	//______________________________________________________________________________
	345	MpPair_t AliMpMotifType::FindLocalIndicesByGassiNum(Int_t gassiNum) const
	346	{
	347	/// Return the connection for the given gassiplex number
	348
	349	AliMpConnection* connection = FindConnectionByGassiNum(gassiNum);
	350
	351	if ( ! connection) return -1;
	352
	353	return connection->GetLocalIndices();
	354	}
	355
	356	//______________________________________________________________________________
	357	MpPair_t AliMpMotifType::FindLocalIndicesByKaptonNum(Int_t kaptonNum) const
	358	{
	359	/// Give the connection related to the given kapton number
	360
	361	AliMpConnection* connection = FindConnectionByKaptonNum(kaptonNum);
	362
	363	if ( ! connection) return -1;
	364
	365	return connection->GetLocalIndices();
	366	}
	367
	368	//______________________________________________________________________________
	369	MpPair_t AliMpMotifType::FindLocalIndicesByBergNum(Int_t bergNum) const
	370	{
	371	/// Retrieve the connection from a Berg connector number
	372
	373	AliMpConnection* connection = FindConnectionByBergNum(bergNum);
	374
	375	if ( ! connection) return -1;
	376
	377	return connection->GetLocalIndices();
	378	}
	379
	380	//______________________________________________________________________________
	381	Bool_t
	382	AliMpMotifType::HasPadByLocalIndices(MpPair_t localIndices) const
	383	{
	384	/// Return true if the pad indexed by \a localIndices has a connection
	385
	386	return ( FindConnectionByLocalIndices(localIndices) != 0x0 );
	387	}
	388
	389	//______________________________________________________________________________
	390	Bool_t
	391	AliMpMotifType::HasPadByLocalIndices(Int_t localIx, Int_t localIy) const
	392	{
	393	/// Return true if the pad indexed by \a localIndices has a connection
	394
	395	return ( FindConnectionByLocalIndices(localIx, localIy) != 0x0 );
	396	}
	397
	398	//______________________________________________________________________________
	399	Bool_t
	400	AliMpMotifType::HasPadByManuChannel(Int_t manuChannel) const
	401	{
	402	/// Return true if the pad indexed by \a localIndices has a connection
	403
	404	// if ( manuChannel >= fNofPads ) return kFALSE;
	405
	406	return ( FindConnectionByGassiNum(manuChannel) != 0x0 );
	407	}
	408
	409	//______________________________________________________________________________
	410	void AliMpMotifType::Print(Option_t *option) const
	411	{
	412	/// Print the map of the motif. In each cell, the value
	413	/// printed depends of option, as the following:
	414	/// - option="N" the "name" of the pad is written
	415	/// - option="K" the Kapton connect. number attached to the pad is written
	416	/// - option="B" the Berg connect. number attached to the pad is written
	417	/// - option="G" the Gassiplex channel number attached to the pad is written
	418	/// otherwise the number of the pad is written
	419	///
	420	/// NOTE : this method is really not optimized, in case 'N' or '',
	421	/// but the Print() this should not be very important in a Print() method
	422
	423	switch (option[0]){
	424	case 'N':cout<<"Name mapping";
	425	break;
	426	case 'K':cout<<"Kapton mapping";
	427	break;
	428	case 'B':cout<<"Berg mapping";
	429	break;
	430	case 'G':cout<<"Gassiplex number mapping";
	431	break;
	432	default:cout<<"Pad mapping";
	433	}
	434	cout<<" in the motif "<<fID<<endl;
	435	cout<<"-----------------------------------"<<endl;
	436
	437	for (Int_t j=fNofPadsY-1;j>=0;j--){
	438	for (Int_t i=0;i<fNofPadsX;i++){
	439	AliMpConnection *connexion = FindConnectionByLocalIndices(i,j);
	440	TString str;
	441	if (connexion){
	442	AliDebug(1,Form("i,j=%2d,%2d connexion=%p",i,j,connexion));
	443
	444	switch (option[0]){
	445	case 'N':str=PadName(connexion->GetPadNum());
	446	break;
	447	case 'K':str=Form("%d",connexion->GetKaptonNum());
	448	break;
	449	case 'B':str=Form("%d",connexion->GetBergNum());
	450	break;
	451	case 'G':str=Form("%d",connexion->GetManuChannel());
	452	break;
	453	default:str= Form("%d",connexion->GetPadNum());
	454	}
	455	cout<<setw(2)<<str;
	456	} else cout<<setw(2)<<"--";
	457	cout<<" ";
	458	}
	459	cout<<endl;
	460	}
	461	}
	462
	463	//_____________________________________________________________________________
	464	Bool_t
	465	AliMpMotifType::Save() const
	466	{
	467	/// Save this motif type
	468
	469	return Save(fID.Data());
	470	}
	471
	472	//_____________________________________________________________________________
	473	Bool_t
	474	AliMpMotifType::Save(const char* motifName) const
	475	{
	476	/// Generate the 2 files needed to describe the motif
	477
	478	TString padPosFileName(AliMpFiles::PadPosFileName(motifName));
	479
	480	TString motifTypeFileName(AliMpFiles::MotifFileName(motifName));
	481
	482	// first a protection : do not allow overwriting existing files...
	483	Bool_t test = gSystem->AccessPathName(padPosFileName.Data());
	484	if (test==kFALSE) // AccessPathName has a strange return value convention...
	485	{
	486	AliError("Cannot overwrite existing padPos file");
	487	return kFALSE;
	488	}
	489	test = gSystem->AccessPathName(motifTypeFileName.Data());
	490	if (test==kFALSE)
	491	{
	492	AliError("Cannot overwrite existing motifType file");
	493	return kFALSE;
	494	}
	495
	496	ofstream padPosFile(padPosFileName.Data());
	497	ofstream motifFile(motifTypeFileName.Data());
	498
	499	motifFile << "# Motif " << motifName << endl
	500	<< "#" << endl
	501	<< "#connecteur_berg kapton padname not_used" << endl
	502	<< "#for slats there's no kapton connector, so it's always 1"
	503	<< " (zero make the reader" << endl
	504	<< "#exit, so it's not a valid value here)." << endl
	505	<< "#" << endl;
	506
	507	for ( Int_t ix = 0; ix < GetNofPadsX(); ++ix )
	508	{
	509	for ( Int_t iy = 0; iy < GetNofPadsY(); ++iy )
	510	{
	511	AliMpConnection* con = FindConnectionByLocalIndices(ix,iy);
	512	if (con)
	513	{
	514	motifFile << con->GetBergNum() << "\t1\t" << con->GetPadNum() << "\t-" << endl;
	515	padPosFile << con->GetPadNum() << "\t" << ix << "\t" << iy << endl;
	516	}
	517	}
	518	}
	519
	520	padPosFile.close();
	521	motifFile.close();
	522
	523	return kTRUE;
	524	}
	525
	526
	527