TPC/AliTPCCalPadRegion.cxx

   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 ////////////////////////////////////////////////////////////////////////////
  17 //
  18 //       === Class for properties specific to pad regions ===
  19 //
  20 //    Each segment of the TPC (i.e. IROC and corresponding OROC) consists
  21 //    of three different pad sizes (short, medium, long). This class
  22 //    is useful for scenarios, where it is appropriate to describe
  23 //    some behaviour per pad size region. It provides an easy interface
  24 //    for getting and setting arbitrary objects for each pad size region.
  25 //    There is no need that this object is of the same type for each
  26 //    pad size region (though it probably will be in most of the cases),
  27 //    nor that it is set at all (e.g. when no data for this region
  28 //    exists and such an object is not needed).
  29 //
  30 //    An example that makes usage of this class is the AliTPCFitPad class
  31 //    which stores TLinearFitter objects for each pad region.
  32 //
  33 ////////////////////////////////////////////////////////////////////////////
  34
  35 #include "AliTPCCalPadRegion.h"
  36 #include "AliTPCROC.h"
  37
  38 ClassImp(AliTPCCalPadRegion)
  39
  40 AliTPCCalPadRegion::AliTPCCalPadRegion():
  41    TNamed(),
  42    fObjects(0)
  43 {
  44    //
  45    // Default constructor.
  46    //
  47 }
  48
  49 AliTPCCalPadRegion::AliTPCCalPadRegion(const char *name, const char *title) :
  50    TNamed(name, title),
  51    fObjects(0)
  52 {
  53    //
  54    // Constructor.
  55    //
  56
  57    fObjects = new TObjArray(fgkNSegments * fgkNPadTypes);
  58    fObjects->SetOwner(kTRUE);
  59 }
  60
  61 AliTPCCalPadRegion::AliTPCCalPadRegion(const AliTPCCalPadRegion& obj) :
  62   TNamed(obj),
  63   fObjects(0)
  64 {
  65    //
  66    // Copy constructor.
  67    //
  68
  69    fObjects = new TObjArray(*(obj.fObjects));
  70    fObjects->SetOwner(kTRUE);
  71 }
  72
  73 AliTPCCalPadRegion& AliTPCCalPadRegion::operator=(const AliTPCCalPadRegion& rhs) {
  74    //
  75    // Assignment operator.
  76    //
  77
  78    if (this != &rhs) {
  79       TNamed::operator=(rhs);
  80       fObjects = new TObjArray(*(rhs.fObjects));
  81    }
  82    return *this;
  83 }
  84
  85
  86 void       AliTPCCalPadRegion::SetObject(TObject* obj, UInt_t segment, UInt_t padType)
  87 {
  88   //
  89   // Set the object for given segment
  90   //
  91   if (!fObjects) {
  92     fObjects = new TObjArray(fgkNSegments * fgkNPadTypes);
  93     fObjects->SetOwner(kTRUE);
  94   }
  95   if (fObjects->GetEntriesFast()<Int_t(fgkNSegments * fgkNPadTypes)){
  96     fObjects->Expand(fgkNSegments * fgkNPadTypes);
  97   }
  98   if (BoundsOk("SetObject", segment, padType)){
  99     if (segment+fgkNSegments*padType>static_cast<UInt_t>(fObjects->GetEntriesFast())) fObjects->Expand(fgkNSegments * fgkNPadTypes);
 100     fObjects->AddAt(obj, segment+fgkNSegments*padType);
 101   }
 102 }
 103
 104 TObject*   AliTPCCalPadRegion::GetObject(UInt_t segment, UInt_t padType){
 105   //
 106   //
 107   //
 108   if (fObjects->GetEntriesFast()<Int_t(fgkNSegments * fgkNPadTypes)){
 109     fObjects->Expand(fgkNSegments * fgkNPadTypes);
 110   }
 111   return fObjects->At(segment+fgkNSegments*padType);
 112 }
 113
 114
 115
 116 void AliTPCCalPadRegion::GetPadRegionCenterLocal(UInt_t padType, Double_t* xy) {
 117    //
 118    // Return the center of the pad size region in local
 119    // coordinates as an Double_t array xy of length 2.
 120    //
 121
 122    Float_t centerPad[3] = {0};
 123    AliTPCROC* tpcROC = AliTPCROC::Instance();
 124
 125    Int_t IOROC = (padType == 0) ? 0 : tpcROC->GetNInnerSector();
 126    //tpcROC->GetPositionLocal(IOROC, tpcROC->GetNRows(IOROC)/2, tpcROC->GetNPads(IOROC, tpcROC->GetNRows(IOROC)/2)/2, centerPad);  // use this instead of the switch statement if you want to calculate the center of the ROC and not the center of the regions with the same pad size
 127    switch (padType) {
 128       case 0:  // short pads
 129          tpcROC->GetPositionLocal(IOROC, tpcROC->GetNRows(IOROC)/2, tpcROC->GetNPads(IOROC, tpcROC->GetNRows(IOROC)/2)/2, centerPad);
 130          break;
 131       case 1:  // medium pads
 132          tpcROC->GetPositionLocal(IOROC, 64/2, tpcROC->GetNPads(IOROC, 64/2)/2, centerPad);
 133          break;
 134       case 2:  // long pads
 135          tpcROC->GetPositionLocal(IOROC, 64+32/2, tpcROC->GetNPads(IOROC, 64+32/2)/2, centerPad);
 136          break;
 137    }
 138
 139    xy[0] = centerPad[0];
 140    xy[1] = centerPad[1];
 141 }
 142
 143 /*UInt_t AliTPCCalPadRegion::GetStartRow(UInt_t padType) {
 144    //
 145    // Returns the index of the
 146    //
 147 }
 148
 149 UInt_t AliTPCCalPadRegion::GetEndRow(UInt_t padType) {
 150
 151 }*/