DigiTaskSND Class Reference

#include <DigiTaskSND.h>

Inheritance diagram for DigiTaskSND:

Collaboration diagram for DigiTaskSND:

Public Member Functions
	DigiTaskSND ()
	~DigiTaskSND ()
virtual InitStatus	Init ()
virtual void	Exec (Option_t *opt)
void	withScifiClusters (bool flag)
void	set_copy_emulsion_points (bool flag)

Private Member Functions
void	digitizeMuFilter ()
void	digitizeScifi ()
void	clusterScifi ()
	DigiTaskSND (const DigiTaskSND &)
DigiTaskSND &	operator= (const DigiTaskSND &)
	ClassDef (DigiTaskSND, 6)

Private Attributes
Scifi *	scifi
std::map< Int_t, std::map< Int_t, std::array< float, 2 > > >	fibresSiPM
std::map< Int_t, std::map< Int_t, std::array< float, 2 > > >	siPMFibres
FairMCEventHeader *	fMCEventHeader
TClonesArray *	fMuFilterPointArray
TClonesArray *	fScifiPointArray
TClonesArray *	fScifiClusterArray
SNDLHCEventHeader *	fEventHeader
TClonesArray *	fMuFilterDigiHitArray
TClonesArray *	fScifiDigiHitArray
TClonesArray *	fMuFilterHit2MCPointsArray
TClonesArray *	fScifiHit2MCPointsArray
TClonesArray *	fvetoPointArray
TClonesArray *	fEmulsionPointArray
TClonesArray *	fMCTrackArray
bool	fMakeClusterScifi
bool	fCopyEmulsionPoints

Detailed Description

Definition at line 16 of file DigiTaskSND.h.

Constructor & Destructor Documentation

DigiTaskSND() [1/2]

DigiTaskSND::DigiTaskSND

(

)

Default constructor

Definition at line 29 of file DigiTaskSND.cxx.

    : FairTask("DigTaskSND")
    , fScifiPointArray(nullptr)
    , fMuFilterPointArray(nullptr)
    , fEventHeader(nullptr)
    , fScifiDigiHitArray(nullptr)
    , fScifiClusterArray(nullptr)
    , fMuFilterDigiHitArray(nullptr)
    , fScifiHit2MCPointsArray(nullptr)
    , fMuFilterHit2MCPointsArray(nullptr)
    , fMakeClusterScifi(true)
    , fCopyEmulsionPoints(false)
{}

~DigiTaskSND()

DigiTaskSND::~DigiTaskSND

(

)

Destructor

Definition at line 43 of file DigiTaskSND.cxx.

{}

DigiTaskSND() [2/2]

DigiTaskSND::DigiTaskSND ( const DigiTaskSND &  )

private

Member Function Documentation

ClassDef()

DigiTaskSND::ClassDef ( DigiTaskSND  , 6    )

private

clusterScifi()

void DigiTaskSND::clusterScifi ( )

private

Definition at line 179 of file DigiTaskSND.cxx.

{    
    map<int, int > hitDict{};
    vector<int> hitList{};
    vector<int> tmp{};
    int index{}, ncl{}, cprev{}, c{}, last{}, first{}, N{};
    
    for (int k = 0, kEnd = fScifiDigiHitArray->GetEntries(); k < kEnd; k++) {
        sndScifiHit* d = static_cast<sndScifiHit*>(fScifiDigiHitArray->At(k));
        if (!d->isValid()) continue;
        hitDict[d->GetDetectorID()] = k ;
        hitList.push_back(d->GetDetectorID());
    }
    if (hitList.size() > 0)
    {
       sort(hitList.begin(), hitList.end()); 
       tmp.push_back(hitList[0]);
       cprev = hitList[0];
       ncl = 0;
       last = hitList.size()-1;
       vector<sndScifiHit*> hitlist{};
       for (int i =0; i<hitList.size(); i++)
       {
            if (i==0 && hitList.size()>1) continue;
            c = hitList[i];
            if (c-cprev ==1) tmp.push_back(c);
            if (c-cprev !=1 || c==hitList[last]){
                first = tmp[0];
                N = tmp.size();
                hitlist.clear();
                for (int j=0; j<tmp.size(); j++)
                {
                    sndScifiHit* aHit = static_cast<sndScifiHit*>(fScifiDigiHitArray->At(hitDict[tmp[j]]));
                    hitlist.push_back(aHit);
                }
                new ((*fScifiClusterArray)[index]) sndCluster(first, N, hitlist, scifi);
                index++;
                if (c!=hitList[last])
                {
                   ncl++;
                   tmp.clear();
                   tmp.push_back(c);
                }
            }
            cprev = c;
        }
     } 
}

digitizeMuFilter()

void DigiTaskSND::digitizeMuFilter ( )

private

Definition at line 228 of file DigiTaskSND.cxx.

{
    // a map with detID and vector(list) of points
    map<int, vector<MuFilterPoint*> > hitContainer{};
    Hit2MCPoints mcLinks;
    map<pair<int, int>, double> mcPoints{};
    map<int, double> norm{};
    int detID{};
 
    // Fill the map
    for (int k = 0, kEnd = fMuFilterPointArray->GetEntries(); k < kEnd; k++) {
        MuFilterPoint* point = static_cast<MuFilterPoint*>(fMuFilterPointArray->At(k));
        if (!point) continue;
        // Collect all hits in same detector element
        detID = point->GetDetectorID();
        hitContainer[detID].push_back(point);
        mcPoints[make_pair(detID, k)] = point->GetEnergyLoss();
        norm[detID]+= point->GetEnergyLoss();
    }
    int index = 0;
    // Loop over entries of the hitContainer map and collect all hits in same detector element
    for (auto it = hitContainer.begin(); it != hitContainer.end(); it++){
        new ((*fMuFilterDigiHitArray)[index]) MuFilterHit(it->first, hitContainer[it->first]);
        index++;
        for (auto mcit = mcPoints.begin(); mcit != mcPoints.end(); mcit++){
            if(it->first == mcit->first.first) mcLinks.Add(it->first, mcit->first.second, mcPoints[make_pair(it->first, mcit->first.second)]/norm[it->first]);
        }
    }
    new((*fMuFilterHit2MCPointsArray)[0]) Hit2MCPoints(mcLinks); 
}

digitizeScifi()

void DigiTaskSND::digitizeScifi ( )

private

Definition at line 134 of file DigiTaskSND.cxx.

{
    // a map containing fibreID and vector(list) of points and weights
    map<int, pair<vector<ScifiPoint*>, vector<float>> > hitContainer{};
    Hit2MCPoints mcLinks;
    map<pair<int, int>, double> mcPoints{};
    map<int, double> norm{};
    int globsipmChan{}, detID{};
    int locFibreID{};
    
    // Fill the map
    for (int k = 0, kEnd = fScifiPointArray->GetEntries(); k < kEnd; k++)
    {
        ScifiPoint* point = static_cast<ScifiPoint*>(fScifiPointArray->At(k));
        if (!point) continue;
        // Collect all hits in same SiPM channel
        detID = point->GetDetectorID();
        locFibreID = detID%100000;
        // Check if locFibreID in a dead area
        if(siPMFibres.count(locFibreID)==0) continue;
        double dE{};
        float weight{};
        for (auto sipmChan : siPMFibres[locFibreID])
        {
            globsipmChan = int(detID/100000)*100000+sipmChan.first;
            weight = sipmChan.second[0];
            hitContainer[globsipmChan].first.push_back(point);
            hitContainer[globsipmChan].second.push_back(weight);
            dE = point->GetEnergyLoss()*weight;
            mcPoints[make_pair(globsipmChan, k)] = dE;
            norm[globsipmChan]+= dE;
        }
    }// End filling map
    int index = 0;
    // Loop over entries of the hitContainer map and collect all hits in same detector element
    for (auto it = hitContainer.begin(); it != hitContainer.end(); it++){
        new ((*fScifiDigiHitArray)[index]) sndScifiHit(it->first, hitContainer[it->first].first, hitContainer[it->first].second);
        index++;
        for (auto mcit = mcPoints.begin(); mcit != mcPoints.end(); mcit++){
            if(it->first == mcit->first.first) mcLinks.Add(it->first, mcit->first.second, mcPoints[make_pair(it->first, mcit->first.second)]/norm[it->first]);
        }
    }
    new((*fScifiHit2MCPointsArray)[0]) Hit2MCPoints(mcLinks);
}

Exec()

void DigiTaskSND::Exec ( Option_t *  opt )

virtual

Virtual method Exec

Definition at line 111 of file DigiTaskSND.cxx.

{
 
    fScifiDigiHitArray->Clear("C");
    if (fMakeClusterScifi) fScifiClusterArray->Clear("C");
    fScifiHit2MCPointsArray->Clear("C");
    fMuFilterDigiHitArray->Clear("C");
    fMuFilterHit2MCPointsArray->Clear("C");
 
    // Set event header
    fEventHeader->SetRunId(fMCEventHeader->GetRunID());
    fEventHeader->SetEventNumber(fMCEventHeader->GetEventID());
    fEventHeader->SetBunchType(101);
 
    // Digitize MC points if any
    if (fMuFilterPointArray) digitizeMuFilter();
    if (fScifiPointArray)
    {
        digitizeScifi();
        if (fMakeClusterScifi) clusterScifi();
    }
}

Init()

InitStatus DigiTaskSND::Init ( )

virtual

Virtual method Init

Definition at line 45 of file DigiTaskSND.cxx.

{
    FairRootManager* ioman = FairRootManager::Instance();
    if (!ioman) {
        LOG(FATAL) << "DigiTaskSND::Init: RootManager not instantiated!";
    }
 
    // Get the SciFi detector and sipm to fibre mapping
    scifi = dynamic_cast<Scifi*> (gROOT->GetListOfGlobals()->FindObject("Scifi") );
    scifi->SiPMmapping();
    fibresSiPM = scifi->GetSiPMmap();
    siPMFibres = scifi->GetFibresMap();
 
    // Get event header
    // Try classic FairRoot approach first
    fMCEventHeader = static_cast<FairMCEventHeader*> (ioman->GetObject("MCEventHeader."));  
    // .. with a safety net for trailing dots mischief
    if ( fMCEventHeader == nullptr ) {
       fMCEventHeader = static_cast<FairMCEventHeader*>(gROOT->FindObjectAny("MCEventHeader."));
    }
     if ( fMCEventHeader == nullptr ) {
       ioman->GetInTree()->SetBranchAddress("MCEventHeader.", &fMCEventHeader);
       LOG(INFO) << "MCEventHeader. branch is found";
    }
    // Get input MC points
    fScifiPointArray = static_cast<TClonesArray*>(ioman->GetObject("ScifiPoint"));
    fvetoPointArray = static_cast<TClonesArray*>(ioman->GetObject("vetoPoint"));
    fEmulsionPointArray = static_cast<TClonesArray*>(ioman->GetObject("EmulsionDetPoint"));
    fMuFilterPointArray = static_cast<TClonesArray*>(ioman->GetObject("MuFilterPoint"));
    if (!fScifiPointArray and !fMuFilterPointArray) {
        LOG(ERROR) << "No Scifi and no MuFilter MC Point array!";
        return kERROR;
    }
    // copy branches from input file:
    fMCTrackArray = static_cast<TClonesArray*>(ioman->GetObject("MCTrack"));
    ioman->Register("MCTrack", "ShipMCTrack", fMCTrackArray, kTRUE);
    ioman->Register("vetoPoint", "vetoPoints", fvetoPointArray, kTRUE);
    ioman->Register("EmulsionDetPoint", "EmulsionDetPoints", fEmulsionPointArray, fCopyEmulsionPoints);
    ioman->Register("ScifiPoint", "ScifiPoints", fScifiPointArray, kTRUE);
    ioman->Register("MuFilterPoint", "MuFilterPoints", fMuFilterPointArray, kTRUE);
 
    // Event header
    fEventHeader = new SNDLHCEventHeader();
    ioman->Register("EventHeader.", "sndEventHeader", fEventHeader, kTRUE);
 
    // Create and register output array - for SciFi and MuFilter
    fScifiDigiHitArray = new TClonesArray("sndScifiHit");
    ioman->Register("Digi_ScifiHits", "DigiScifiHit_det", fScifiDigiHitArray, kTRUE);
    // Branche containing links to MC truth info
    fScifiHit2MCPointsArray = new TClonesArray("Hit2MCPoints");
    ioman->Register("Digi_ScifiHits2MCPoints", "DigiScifiHits2MCPoints_det", fScifiHit2MCPointsArray, kTRUE);
    fScifiHit2MCPointsArray->BypassStreamer(kTRUE);
    if ( fMakeClusterScifi )  {
       fScifiClusterArray = new TClonesArray("sndCluster");
       ioman->Register("Cluster_Scifi", "ScifiCluster_det", fScifiClusterArray, kTRUE);
    }
    fMuFilterDigiHitArray = new TClonesArray("MuFilterHit");
    ioman->Register("Digi_MuFilterHits", "DigiMuFilterHit_det", fMuFilterDigiHitArray, kTRUE);
    // Branche containing links to MC truth info
    fMuFilterHit2MCPointsArray = new TClonesArray("Hit2MCPoints");
    ioman->Register("Digi_MuFilterHits2MCPoints", "DigiMuFilterHits2MCPoints_det", fMuFilterHit2MCPointsArray, kTRUE);
    fMuFilterHit2MCPointsArray->BypassStreamer(kTRUE);
    
    return kSUCCESS;
}

operator=()

DigiTaskSND & DigiTaskSND::operator= ( const DigiTaskSND &  )

private

set_copy_emulsion_points()

void DigiTaskSND::set_copy_emulsion_points ( bool  flag )

inline

Set flag to copy emulsion points to output file

Definition at line 35 of file DigiTaskSND.h.

{ fCopyEmulsionPoints = flag; }

withScifiClusters()

void DigiTaskSND::withScifiClusters ( bool  flag )

inline

Set flag for Scifi cluster making

Definition at line 32 of file DigiTaskSND.h.

{ fMakeClusterScifi = flag; }

Member Data Documentation

fCopyEmulsionPoints

bool DigiTaskSND::fCopyEmulsionPoints

private

Definition at line 63 of file DigiTaskSND.h.

fEmulsionPointArray

TClonesArray* DigiTaskSND::fEmulsionPointArray

private

Definition at line 58 of file DigiTaskSND.h.

fEventHeader

SNDLHCEventHeader* DigiTaskSND::fEventHeader

private

Definition at line 52 of file DigiTaskSND.h.

fibresSiPM

std::map<Int_t, std::map<Int_t, std::array<float, 2> > > DigiTaskSND::fibresSiPM

private

Definition at line 43 of file DigiTaskSND.h.

fMakeClusterScifi

bool DigiTaskSND::fMakeClusterScifi

private

Flags

Definition at line 62 of file DigiTaskSND.h.

fMCEventHeader

FairMCEventHeader* DigiTaskSND::fMCEventHeader

private

Definition at line 47 of file DigiTaskSND.h.

fMCTrackArray

TClonesArray* DigiTaskSND::fMCTrackArray

private

Definition at line 59 of file DigiTaskSND.h.

fMuFilterDigiHitArray

TClonesArray* DigiTaskSND::fMuFilterDigiHitArray

private

Definition at line 53 of file DigiTaskSND.h.

fMuFilterHit2MCPointsArray

TClonesArray* DigiTaskSND::fMuFilterHit2MCPointsArray

private

Definition at line 55 of file DigiTaskSND.h.

fMuFilterPointArray

TClonesArray* DigiTaskSND::fMuFilterPointArray

private

Definition at line 48 of file DigiTaskSND.h.

fScifiClusterArray

TClonesArray* DigiTaskSND::fScifiClusterArray

private

Definition at line 50 of file DigiTaskSND.h.

fScifiDigiHitArray

TClonesArray* DigiTaskSND::fScifiDigiHitArray

private

Definition at line 54 of file DigiTaskSND.h.

fScifiHit2MCPointsArray

TClonesArray* DigiTaskSND::fScifiHit2MCPointsArray

private

Definition at line 56 of file DigiTaskSND.h.

fScifiPointArray

TClonesArray* DigiTaskSND::fScifiPointArray

private

Definition at line 49 of file DigiTaskSND.h.

fvetoPointArray

TClonesArray* DigiTaskSND::fvetoPointArray

private

Definition at line 57 of file DigiTaskSND.h.

scifi

Scifi* DigiTaskSND::scifi

private

Definition at line 42 of file DigiTaskSND.h.

siPMFibres

std::map<Int_t, std::map<Int_t,std:: array<float, 2> > > DigiTaskSND::siPMFibres

private

Definition at line 44 of file DigiTaskSND.h.

---

The documentation for this class was generated from the following files:

• sndFairTasks/DigiTaskSND.h
• sndFairTasks/DigiTaskSND.cxx