ROOT logo
/**************************************************************************
 * Copyright(c) 2002-2003, 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.                  *
 **************************************************************************/

#include <Riostream.h>
#include "AliITSTableSSD.h"

using std::endl;
using std::cout;
using std::cerr;
ClassImp(AliITSTableSSD)
////////////////////////////////////////////////////////////////////////
// Version: 0                                                         //
// Origin: Massimo Masera                                             //
// March 2002                                                         //
//                                                                    //
// AliITSTableSSD is used by AliITSsimulationSSD class to fill the AliITSpList
// object starting from the map with energy depositions
////////////////////////////////////////////////////////////////////////
//----------------------------------------------------------------------
AliITSTableSSD::AliITSTableSSD() : TObject(),
fDim(0),
fArray(0){
  // Default Constructor
  for(Int_t i=0;i<2;i++){
    fCurrUse[i]=0;
    fCurrFil[i]=0;
  }
}
//----------------------------------------------------------------------
AliITSTableSSD::AliITSTableSSD(const AliITSTableSSD & source):TObject(source),
fDim(source.fDim),
fArray(source.fArray){
  // Copy constructor

    if(this == &source) return;
    fArray = new Int_t [fDim];
    fCurrUse[0]=(source.fCurrUse)[0];
    fCurrUse[1]=(source.fCurrUse)[1];
    fCurrFil[0]=(source.fCurrFil)[0];
    fCurrFil[1]=(source.fCurrFil)[1];
    for(Int_t i=0;i<fDim;i++)fArray[i]=(source.fArray)[i];
}
//----------------------------------------------------------------------
AliITSTableSSD& AliITSTableSSD::operator=(const AliITSTableSSD & source){
  // = opporator constructor

    if(this == &source) return *this;
    fDim=source.fDim;
    if(fArray)delete [] fArray;
    fArray = new Int_t [fDim];
    fCurrUse[0]=(source.fCurrUse)[0];
    fCurrUse[1]=(source.fCurrUse)[1];
    fCurrFil[0]=(source.fCurrFil)[0];
    fCurrFil[1]=(source.fCurrFil)[1];
    for(Int_t i=0;i<fDim;i++)fArray[i]=(source.fArray)[i];
    return *this;
}
//----------------------------------------------------------------------
AliITSTableSSD::AliITSTableSSD(Int_t noelem) : TObject(),
fDim(0),
fArray(0){
  // Standard constructor
  fDim=noelem*2;
  fArray = new Int_t [fDim];
  Clear();
}
//----------------------------------------------------------------------
AliITSTableSSD::~AliITSTableSSD(){
  // Destructor
  delete [] fArray;
  fArray=0;
}
//----------------------------------------------------------------------
void AliITSTableSSD::Add(Int_t side,Int_t strip){
  // Add an element to the table
  if(strip>=fDim/2){
    cerr<<" Error in AliITSTableSSD::Add. "<<strip<<" is out of range\n";
    return;
  }
  if((side!=0) && (side!=1)){
    cerr<<" Error in AliITSTableSSD::Add. side="<<side<<endl;
    cerr<<" side must be 0 or 1\n";
    return;
  }
  if(fCurrFil[side]>(fDim/2-1)){
    cerr<<" Error in AliITSTableSSD::Add. Trying to fill an element out of range\n";
    cerr<<" Element="<<fCurrFil[side]<<" while max limit is "<<(fDim/2-1)<<endl;
    fCurrFil[side]++;
    return;
  }
  // P side = 0 and N side =1
  Int_t index=(fDim/2)*side+fCurrFil[side];
  Int_t * ptr= &fArray[(fDim/2)*side];
  if(SearchValue(ptr,strip,fCurrFil[side])>=0)return;
  fArray[index]=strip;
  fCurrFil[side]++;
}
//----------------------------------------------------------------------
void AliITSTableSSD::Clear(){
  //clear arrays
  fCurrUse[0]= 0;
  fCurrUse[1] = 0;
  fCurrFil[0]= 0;
  fCurrFil[1] = 0;
  for(Int_t i=0;i<fDim;i++)fArray[i]=-1;
}
//----------------------------------------------------------------------
void AliITSTableSSD::DumpTable(){
  // Dumps the contents of the table
  cout<<"==============================================================\n";
  cout<<" AliITSTableSSD::DumpTable \n";
  cout<<" Dimension of the table "<<fDim<<" ("<<fDim/2<<" per side)\n";
  cout<<" Current element to be filled for P side "<<fCurrFil[0]<<endl;
  cout<<" Current element to be filled for N side "<<fCurrFil[1]<<endl;
  cout<<" Current element in use for P side "<<fCurrUse[0]<<endl;
  cout<<" Current element in use for N side "<<fCurrUse[1]<<endl;
  cout<<"\n Elements for P side: \n";
  for(Int_t i=0; i<fCurrFil[0];i++){
    printf("%6d ",fArray[i]);
    if(i%6==0 && i>0)printf("\n");
  }
  printf("\n");
  cout<<"\n Elements for N side: \n";
  for(Int_t i=0; i<fCurrFil[1];i++){
    printf("%6d ",fArray[fDim/2+i]);
    if(i%6==0 && i>0)printf("\n");
  }
  printf("\n");
}

//----------------------------------------------------------------------
Int_t AliITSTableSSD::Use(Int_t side){
  // uses the current element. This means that the current element is returned
  // and its content is replaced by -1. Hence each element can be used only 
  // once.
  Int_t elem=-1;
  if((side!=0) && (side!=1)){
    cerr<<" Error in AliITSTableSSD::Use. side="<<side<<endl;
    cerr<<" side must be 0 or 1\n";
    return elem;
  }
  if(fCurrUse[side]>(fDim/2-1)){
    cerr<<" Error in AliITSTableSSD::Use. Trying to use an element out of range\n";
    cerr<<" Element="<<fCurrUse[side]<<" while max limit is "<<(fDim/2-1)<<endl;
    fCurrUse[side]++;
    return elem;
  }
  Int_t index=(fDim/2)*side+fCurrUse[side];
  elem=fArray[index];
  fArray[index]=-1;
  fCurrUse[side]++;
  return elem;
}
 AliITSTableSSD.cxx:1
 AliITSTableSSD.cxx:2
 AliITSTableSSD.cxx:3
 AliITSTableSSD.cxx:4
 AliITSTableSSD.cxx:5
 AliITSTableSSD.cxx:6
 AliITSTableSSD.cxx:7
 AliITSTableSSD.cxx:8
 AliITSTableSSD.cxx:9
 AliITSTableSSD.cxx:10
 AliITSTableSSD.cxx:11
 AliITSTableSSD.cxx:12
 AliITSTableSSD.cxx:13
 AliITSTableSSD.cxx:14
 AliITSTableSSD.cxx:15
 AliITSTableSSD.cxx:16
 AliITSTableSSD.cxx:17
 AliITSTableSSD.cxx:18
 AliITSTableSSD.cxx:19
 AliITSTableSSD.cxx:20
 AliITSTableSSD.cxx:21
 AliITSTableSSD.cxx:22
 AliITSTableSSD.cxx:23
 AliITSTableSSD.cxx:24
 AliITSTableSSD.cxx:25
 AliITSTableSSD.cxx:26
 AliITSTableSSD.cxx:27
 AliITSTableSSD.cxx:28
 AliITSTableSSD.cxx:29
 AliITSTableSSD.cxx:30
 AliITSTableSSD.cxx:31
 AliITSTableSSD.cxx:32
 AliITSTableSSD.cxx:33
 AliITSTableSSD.cxx:34
 AliITSTableSSD.cxx:35
 AliITSTableSSD.cxx:36
 AliITSTableSSD.cxx:37
 AliITSTableSSD.cxx:38
 AliITSTableSSD.cxx:39
 AliITSTableSSD.cxx:40
 AliITSTableSSD.cxx:41
 AliITSTableSSD.cxx:42
 AliITSTableSSD.cxx:43
 AliITSTableSSD.cxx:44
 AliITSTableSSD.cxx:45
 AliITSTableSSD.cxx:46
 AliITSTableSSD.cxx:47
 AliITSTableSSD.cxx:48
 AliITSTableSSD.cxx:49
 AliITSTableSSD.cxx:50
 AliITSTableSSD.cxx:51
 AliITSTableSSD.cxx:52
 AliITSTableSSD.cxx:53
 AliITSTableSSD.cxx:54
 AliITSTableSSD.cxx:55
 AliITSTableSSD.cxx:56
 AliITSTableSSD.cxx:57
 AliITSTableSSD.cxx:58
 AliITSTableSSD.cxx:59
 AliITSTableSSD.cxx:60
 AliITSTableSSD.cxx:61
 AliITSTableSSD.cxx:62
 AliITSTableSSD.cxx:63
 AliITSTableSSD.cxx:64
 AliITSTableSSD.cxx:65
 AliITSTableSSD.cxx:66
 AliITSTableSSD.cxx:67
 AliITSTableSSD.cxx:68
 AliITSTableSSD.cxx:69
 AliITSTableSSD.cxx:70
 AliITSTableSSD.cxx:71
 AliITSTableSSD.cxx:72
 AliITSTableSSD.cxx:73
 AliITSTableSSD.cxx:74
 AliITSTableSSD.cxx:75
 AliITSTableSSD.cxx:76
 AliITSTableSSD.cxx:77
 AliITSTableSSD.cxx:78
 AliITSTableSSD.cxx:79
 AliITSTableSSD.cxx:80
 AliITSTableSSD.cxx:81
 AliITSTableSSD.cxx:82
 AliITSTableSSD.cxx:83
 AliITSTableSSD.cxx:84
 AliITSTableSSD.cxx:85
 AliITSTableSSD.cxx:86
 AliITSTableSSD.cxx:87
 AliITSTableSSD.cxx:88
 AliITSTableSSD.cxx:89
 AliITSTableSSD.cxx:90
 AliITSTableSSD.cxx:91
 AliITSTableSSD.cxx:92
 AliITSTableSSD.cxx:93
 AliITSTableSSD.cxx:94
 AliITSTableSSD.cxx:95
 AliITSTableSSD.cxx:96
 AliITSTableSSD.cxx:97
 AliITSTableSSD.cxx:98
 AliITSTableSSD.cxx:99
 AliITSTableSSD.cxx:100
 AliITSTableSSD.cxx:101
 AliITSTableSSD.cxx:102
 AliITSTableSSD.cxx:103
 AliITSTableSSD.cxx:104
 AliITSTableSSD.cxx:105
 AliITSTableSSD.cxx:106
 AliITSTableSSD.cxx:107
 AliITSTableSSD.cxx:108
 AliITSTableSSD.cxx:109
 AliITSTableSSD.cxx:110
 AliITSTableSSD.cxx:111
 AliITSTableSSD.cxx:112
 AliITSTableSSD.cxx:113
 AliITSTableSSD.cxx:114
 AliITSTableSSD.cxx:115
 AliITSTableSSD.cxx:116
 AliITSTableSSD.cxx:117
 AliITSTableSSD.cxx:118
 AliITSTableSSD.cxx:119
 AliITSTableSSD.cxx:120
 AliITSTableSSD.cxx:121
 AliITSTableSSD.cxx:122
 AliITSTableSSD.cxx:123
 AliITSTableSSD.cxx:124
 AliITSTableSSD.cxx:125
 AliITSTableSSD.cxx:126
 AliITSTableSSD.cxx:127
 AliITSTableSSD.cxx:128
 AliITSTableSSD.cxx:129
 AliITSTableSSD.cxx:130
 AliITSTableSSD.cxx:131
 AliITSTableSSD.cxx:132
 AliITSTableSSD.cxx:133
 AliITSTableSSD.cxx:134
 AliITSTableSSD.cxx:135
 AliITSTableSSD.cxx:136
 AliITSTableSSD.cxx:137
 AliITSTableSSD.cxx:138
 AliITSTableSSD.cxx:139
 AliITSTableSSD.cxx:140
 AliITSTableSSD.cxx:141
 AliITSTableSSD.cxx:142
 AliITSTableSSD.cxx:143
 AliITSTableSSD.cxx:144
 AliITSTableSSD.cxx:145
 AliITSTableSSD.cxx:146
 AliITSTableSSD.cxx:147
 AliITSTableSSD.cxx:148
 AliITSTableSSD.cxx:149
 AliITSTableSSD.cxx:150
 AliITSTableSSD.cxx:151
 AliITSTableSSD.cxx:152
 AliITSTableSSD.cxx:153
 AliITSTableSSD.cxx:154
 AliITSTableSSD.cxx:155
 AliITSTableSSD.cxx:156
 AliITSTableSSD.cxx:157
 AliITSTableSSD.cxx:158
 AliITSTableSSD.cxx:159
 AliITSTableSSD.cxx:160
 AliITSTableSSD.cxx:161
 AliITSTableSSD.cxx:162
 AliITSTableSSD.cxx:163
 AliITSTableSSD.cxx:164
 AliITSTableSSD.cxx:165