HalfDiskSegmentation.cxx

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
 
#include "TClonesArray.h"
 
#include <fairlogger/Logger.h>
 
#include "ITSMFTBase/SegmentationAlpide.h"
#include "MFTBase/HalfDiskSegmentation.h"
#include "MFTBase/Geometry.h"
#include "MFTBase/GeometryTGeo.h"
 
using namespace o2::mft;
using namespace o2::itsmft;
 
ClassImp(HalfDiskSegmentation);
 
 
//_____________________________________________________________________________
HalfDiskSegmentation::HalfDiskSegmentation() : VSegmentation(), mNLadders(0), mLadders(nullptr) {}
 
 
//_____________________________________________________________________________
HalfDiskSegmentation::HalfDiskSegmentation(UInt_t uniqueID) : VSegmentation(), mNLadders(0), mLadders(nullptr)
{
 
  // constructor
  SetUniqueID(uniqueID);
 
  LOG(debug1) << "Start creating half-disk UniqueID = " << GetUniqueID();
 
  Geometry* mftGeom = Geometry::instance();
 
  SetName(Form("%s_%d_%d", GeometryTGeo::getMFTDiskPattern(), mftGeom->getHalfID(GetUniqueID()),
               mftGeom->getDiskID(GetUniqueID())));
 
  mLadders = new TClonesArray("o2::mft::LadderSegmentation");
  mLadders->SetOwner(kTRUE);
}
 
 
//_____________________________________________________________________________
HalfDiskSegmentation::HalfDiskSegmentation(const HalfDiskSegmentation& input)
  : VSegmentation(input), mNLadders(input.mNLadders)
{
 
  // copy constructor
  if (input.mLadders) {
    mLadders = new TClonesArray(*(input.mLadders));
  } else {
    mLadders = new TClonesArray("o2::mft::LadderSegmentation");
  }
  mLadders->SetOwner(kTRUE);
}
 
//_____________________________________________________________________________
HalfDiskSegmentation::~HalfDiskSegmentation() { Clear(""); }
 
 
//_____________________________________________________________________________
void HalfDiskSegmentation::Clear(const Option_t* /*opt*/)
{
 
  if (mLadders) {
    mLadders->Delete();
  }
  delete mLadders;
  mLadders = nullptr;
}
 
 
//_____________________________________________________________________________
void HalfDiskSegmentation::createLadders(TXMLEngine* xml, XMLNodePointer_t node)
{
  Int_t iladder;
  Int_t nsensor;
  Double_t pos[3];
  Double_t ang[3] = {0., 0., 0.};
 
  Geometry* mftGeom = Geometry::instance();
 
  TString nodeName = xml->GetNodeName(node);
  if (!nodeName.CompareTo("ladder")) {
    XMLAttrPointer_t attr = xml->GetFirstAttr(node);
    while (attr != nullptr) {
      TString attrName = xml->GetAttrName(attr);
      TString attrVal = xml->GetAttrValue(attr);
      if (!attrName.CompareTo("iladder")) {
        iladder = attrVal.Atoi();
        if (iladder >= getNLadders() || iladder < 0) {
          LOG(fatal) << "Wrong ladder number : " << iladder;
        }
      } else if (!attrName.CompareTo("nsensor")) {
        nsensor = attrVal.Atoi();
      } else if (!attrName.CompareTo("xpos")) {
        pos[0] = attrVal.Atof();
      } else if (!attrName.CompareTo("ypos")) {
        pos[1] = attrVal.Atof();
      } else if (!attrName.CompareTo("zpos")) {
        pos[2] = attrVal.Atof();
      } else if (!attrName.CompareTo("phi")) {
        ang[0] = attrVal.Atof();
      } else if (!attrName.CompareTo("theta")) {
        ang[1] = attrVal.Atof();
      } else if (!attrName.CompareTo("psi")) {
        ang[2] = attrVal.Atof();
      } else {
        LOG(error) << "Unknwon Attribute name " << xml->GetAttrName(attr);
      }
      attr = xml->GetNextAttr(attr);
    }
 
    Int_t plane = -1;
    Int_t ladderID = iladder;
    if (iladder < getNLadders() / 2) {
      plane = 0;
    } else {
      plane = 1;
      // ladderID -= getNLadders()/2;
    }
 
    UInt_t ladderUniqueID = mftGeom->getObjectID(Geometry::LadderType, mftGeom->getHalfID(GetUniqueID()),
                                                 mftGeom->getDiskID(GetUniqueID()), plane, ladderID);
 
    auto* ladder = new LadderSegmentation(ladderUniqueID);
    ladder->setNSensors(nsensor);
    ladder->setPosition(pos);
    ladder->setRotationAngles(ang);
 
    ladder->createSensors(xml, node);
 
    new ((*mLadders)[iladder]) LadderSegmentation(*ladder);
    delete ladder;
 
    // getLadder(iladder)->Print();
  }
 
  // display all child nodes
  XMLNodePointer_t child = xml->GetChild(node);
  while (child != nullptr) {
    createLadders(xml, child);
    child = xml->GetNext(child);
  }
}
 
 
//_____________________________________________________________________________
Int_t HalfDiskSegmentation::getNChips()
{
 
  Int_t nChips = 0;
 
  for (Int_t iLadder = 0; iLadder < mLadders->GetEntries(); iLadder++) {
 
    LadderSegmentation* ladder = (LadderSegmentation*)mLadders->At(iLadder);
    nChips += ladder->getNSensors();
  }
 
  return nChips;
}
 
 
//_____________________________________________________________________________
void HalfDiskSegmentation::print(Option_t* opt)
{
 
  getTransformation()->Print();
  if (opt && (strstr(opt, "ladder") || strstr(opt, "l"))) {
    for (int i = 0; i < getNLadders(); i++) {
      getLadder(i)->Print(opt);
    }
  }
}