BmnEcal.cxx

Go to the documentation of this file.

 
/*************************************************************************************
 *
 *         Class BmnEcal
 *
 *  Adopted for BMN by:   Elena Litvinenko (EL)
 *  e-mail:   litvin@nf.jinr.ru
 *  Version:  10-02-2016
 *  Last update:  10-02-2016 (EL)
 *  Updated:  23-06-2021 by Petr Alekseev <pnaleks@gmail.com>
 *
 ************************************************************************************/
 
#include "BmnEcal.h"
 
#include "BmnEcalGeo.h"
#include "BmnEcalPoint.h"
#include "CbmStack.h"
#include "FairGeoInterface.h"
#include "FairGeoLoader.h"
#include "FairGeoNode.h"
#include "FairGeoRootBuilder.h"
#include "FairRootManager.h"
#include "FairRun.h"
#include "FairRuntimeDb.h"
#include "FairVolume.h"
#include "TClonesArray.h"
#include "TGeoArb8.h"
#include "TGeoMCGeometry.h"
#include "TGeoManager.h"
#include "TLorentzVector.h"
#include "TObjArray.h"
#include "TParticle.h"
#include "TParticlePDG.h"
#include "TVirtualMC.h"
 
#include <iostream>
 
// -----   Default constructor   -------------------------------------------
BmnEcal::BmnEcal()
{
    fEcalCollection = new TClonesArray("BmnEcalPoint");
    fVerboseLevel = 1;
}
// -------------------------------------------------------------------------
 
// -----   Standard constructor   ------------------------------------------
BmnEcal::BmnEcal(const char* name, Bool_t active)
    : FairDetector(name, active)
{
    fEcalCollection = new TClonesArray("BmnEcalPoint");
    fVerboseLevel = 1;
}
// -------------------------------------------------------------------------
 
// -----   Destructor   ----------------------------------------------------
BmnEcal::~BmnEcal()
{
    if (fEcalCollection) {
        fEcalCollection->Delete();
        delete fEcalCollection;
    }
}
// -------------------------------------------------------------------------
 
// -----   Public method Intialize   ---------------------------------------
void BmnEcal::Initialize()
{
    // Init function
 
    FairDetector::Initialize();
    // FairRun* sim = FairRun::Instance();
    // FairRuntimeDb* rtdb=sim->GetRuntimeDb();
}
// -------------------------------------------------------------------------
 
void BmnEcal::BeginEvent()
{
    // Begin of the event
}
 
// -----   Public method ProcessHits  --------------------------------------
Bool_t BmnEcal::ProcessHits(FairVolume* vol)
{
 
// #define EDEBUG
#ifdef EDEBUG
    static Int_t lEDEBUGcounter = 0;
    if (lEDEBUGcounter < 1)
        std::cout << "EDEBUG-- BmnEcal::ProcessHits: entered" << gMC->CurrentVolPath() << endl;
#endif
    // #undef EDEBUG
 
    if (gMC->IsTrackEntering()) {
        fELoss = 0.;
        fTime = gMC->TrackTime() * 1.0e09;
        fLength = gMC->TrackLength();
        gMC->TrackPosition(fPos);
        gMC->TrackMomentum(fMom);
    }
 
    fELoss += gMC->Edep();
 
    if (gMC->IsTrackExiting() || gMC->IsTrackStop() || gMC->IsTrackDisappeared()) {
 
        if (fELoss == 0.)
            return kFALSE;
 
        fTrackID = gMC->GetStack()->GetCurrentTrackNumber();
        fVolumeID = vol->getMCid();
 
        // Using data of the exiting track instead of the entering (why?)
        fTime = gMC->TrackTime() * 1.0e09;
        fLength = gMC->TrackLength();
        gMC->TrackPosition(fPos);
        gMC->TrackMomentum(fMom);
 
        Int_t copyNo;
        gMC->CurrentVolID(copyNo);
        Int_t copyNoMother;
        gMC->CurrentVolOffID(1, copyNoMother);
 
        AddHit(fTrackID, fVolumeID, copyNo, copyNoMother, TVector3(fPos.X(), fPos.Y(), fPos.Z()),
               TVector3(fMom.Px(), fMom.Py(), fMom.Pz()), fTime, fLength, fELoss);
 
        ((CbmStack*)gMC->GetStack())->AddPoint(kECAL);
    }
 
    return kTRUE;
}
 
// ----------------------------------------------------------------------------
 
// -----   Public method EndOfEvent   -----------------------------------------
void BmnEcal::EndOfEvent()
{
    if (fVerboseLevel)
        Print("");
    Reset();
}
 
// -----   Public method Register   -------------------------------------------
void BmnEcal::Register()
{
    FairRootManager::Instance()->Register("EcalPoint", "Ecal", fEcalCollection, fToFile);
}
 
// -----   Public method GetCollection   --------------------------------------
TClonesArray* BmnEcal::GetCollection(Int_t iColl) const
{
    if (iColl == 0)
        return fEcalCollection;
 
    return NULL;
}
 
// -----   Public method Print   ----------------------------------------------
void BmnEcal::Print(Option_t*) const
{
    Int_t nHits = fEcalCollection->GetEntriesFast();
    cout << "-I- BmnEcal: " << nHits << " points registered in this event." << endl;
 
    if (fVerboseLevel > 1)
        for (Int_t i = 0; i < nHits; i++)
            (*fEcalCollection)[i]->Print();
}
 
// -----   Public method Reset   ----------------------------------------------
void BmnEcal::Reset()
{
    fEcalCollection->Clear();
}
 
// guarda in FairRootManager::CopyClones
// -----   Public method CopyClones   -----------------------------------------
void BmnEcal::CopyClones(TClonesArray* cl1, TClonesArray* cl2, Int_t offset)
{
    Int_t nEntries = cl1->GetEntriesFast();
    // cout << "-I- BmnEcal: " << nEntries << " entries to add." << endl;
    TClonesArray& clref = *cl2;
    BmnEcalPoint* oldpoint = NULL;
    for (Int_t i = 0; i < nEntries; i++) {
        oldpoint = (BmnEcalPoint*)cl1->At(i);
        Int_t index = oldpoint->GetTrackID() + offset;
        oldpoint->SetTrackID(index);
        new (clref[cl2->GetEntriesFast()]) BmnEcalPoint(*oldpoint);
    }
    cout << " -I- BmnEcal: " << cl2->GetEntriesFast() << " merged entries." << endl;
}
 
// -----   Public method ConstructGeometry   ----------------------------------
void BmnEcal::ConstructGeometry()
{
 
    TString geoFileName = GetGeometryFileName();
    if (geoFileName.EndsWith(".root")) {
        LOG(info) << "Constructing ECAL geometry from ROOT file " << geoFileName.Data();
        ConstructRootGeometry();
        return;
    }
 
    FairGeoLoader* geoLoad = FairGeoLoader::Instance();
    FairGeoInterface* geoFace = geoLoad->getGeoInterface();
    BmnEcalGeo* ecalGeo = new BmnEcalGeo();
    ecalGeo->setGeomFile(GetGeometryFileName());
    geoFace->addGeoModule(ecalGeo);
 
    Bool_t rc = geoFace->readSet(ecalGeo);
    if (rc)
        ecalGeo->create(geoLoad->getGeoBuilder());
    TList* volList = ecalGeo->getListOfVolumes();
 
    // store geo parameter
    FairRun* fRun = FairRun::Instance();
    FairRuntimeDb* rtdb = FairRun::Instance()->GetRuntimeDb();
    BmnEcalGeoPar* par = (BmnEcalGeoPar*)(rtdb->getContainer("BmnEcalGeoPar"));
    TObjArray* fSensNodes = par->GetGeoSensitiveNodes();
    TObjArray* fPassNodes = par->GetGeoPassiveNodes();
 
    TListIter iter(volList);
    FairGeoNode* node = NULL;
    FairGeoVolume* aVol = NULL;
 
    while ((node = (FairGeoNode*)iter.Next())) {
        aVol = dynamic_cast<FairGeoVolume*>(node);
 
        if (node->isSensitive()) {
            fSensNodes->AddLast(aVol);
        } else {
            fPassNodes->AddLast(aVol);
        }
    }
    par->setChanged();
    par->setInputVersion(fRun->GetRunId(), 1);
 
    ProcessNodes(volList);
}
 
// -----   Public method CheckIfSensitive   -----------------------------------
Bool_t BmnEcal::CheckIfSensitive(std::string name)
{
    TString tsname = name;
    if (tsname.Contains("laySci"))
        return kTRUE;   // lay
 
    return kFALSE;
}
 
// -----   Private method AddHit   --------------------------------------------
BmnEcalPoint* BmnEcal::AddHit(Int_t trackID,
                              Int_t detID,
                              Int_t copyNo,
                              Int_t copyNoMother,
                              TVector3 pos,
                              TVector3 mom,
                              Double_t time,
                              Double_t length,
                              Double_t eLoss)
{
    TClonesArray& clref = *fEcalCollection;
    Int_t size = clref.GetEntriesFast();
    return new (clref[size]) BmnEcalPoint(trackID, detID, copyNo, copyNoMother, pos, mom, time, length, eLoss);
}