PndDiscTaskPID Class Reference

#include <PndDiscTaskPID.h>

Inheritance diagram for PndDiscTaskPID:

Public Member Functions
	PndDiscTaskPID ()
	PndDiscTaskPID (const char *name)
virtual	~PndDiscTaskPID ()
virtual InitStatus	Init ()
virtual InitStatus	ReInit ()
virtual void	Exec (Option_t *opt)
virtual void	FinishEvent ()
virtual void	FinishTask ()
void	RunTimeBased (Bool_t time_based)
void	SetPersistency (Bool_t val=kTRUE)
Bool_t	GetPersistency ()

Protected Member Functions
double	gauss (int x, double mean, double rms)
double	mean (std::vector< double > values)
double	deviation (double mean, std::vector< double > values)

Protected Attributes
TString	branch_name_digits
	Branch name where digitized hits are stored. More...
TString	folder_name_digits
	Folder name for digits. More...
TClonesArray *	tclarr_digits
TClonesArray *	tclarr_recon_results
TClonesArray *	tclarr_particles_in
TClonesArray *	tclarr_pid_results
	results of reconstruction (pattern matching) More...
Bool_t	is_time_based
	Time based buffering on/off. More...

Detailed Description

Definition at line 24 of file PndDiscTaskPID.h.

Constructor & Destructor Documentation

PndDiscTaskPID::PndDiscTaskPID

(

)

Definition at line 68 of file PndDiscTaskPID.cxx.

References branch_name_digits, and folder_name_digits.

                               : PndPersistencyTask("PndDiscTaskPID")
{
    branch_name_digits    = "DiscPatternPrediction";
    folder_name_digits    = "DiscDIRC";
}

PndDiscTaskPID::PndDiscTaskPID

(

const char *

name

)

PndDiscTaskPID::~PndDiscTaskPID ( )

virtual

Definition at line 77 of file PndDiscTaskPID.cxx.

{
}

Member Function Documentation

double PndDiscTaskPID::deviation ( double  mean, std::vector< double >  values  )

protected

Definition at line 51 of file PndDiscTaskPID.cxx.

References i, and sqrt().

Referenced by Exec().

{
    double average = 0;

    for(size_t i = 0; i < values.size(); i++)
    {
        average += (values[i]-mean_value)*(values[i]-mean_value);
    }

    average = sqrt(1/(double(values.size())-1)*average);

    return average;
}

void PndDiscTaskPID::Exec ( Option_t *  opt )

virtual

Definition at line 147 of file PndDiscTaskPID.cxx.

References deviation(), gauss(), PndDiscDigitizedHit::GetDetectorID(), PndDiscDigitizedHit::GetPixelNumber(), PndDiscDigitizedHit::GetReadoutID(), PndDiscDigitizedHit::GetTdcTime(), PndDiscReconResult::hypothesis, i, PndDiscPID::kaon, log(), PndDiscPID::loglikekaon, PndDiscPID::loglikepion, PndDiscPID::loglikeproton, mean(), p, PndDiscReconResult::particle, particle, phi, PndDiscPID::pion, PndDiscReconResult::pixel, PndDiscPID::proton, pz, t, tclarr_digits, tclarr_particles_in, tclarr_pid_results, tclarr_recon_results, theta, PndDiscReconResult::time, x0, and y0.

{
    //Reading out entries
    int particles = tclarr_particles_in->GetEntries();
    int entries = tclarr_recon_results->GetEntries();
    int digits = tclarr_digits->GetEntries();

    std::cout << "Number of particles: " << particles << std::endl;

    //Information of theoretical hit pattern
    std::vector<std::vector<std::vector<int> > > pixel_prediction; //Predicted hit pattern
    std::vector<std::vector<std::vector<double> > > time_prediction; //Predicted time of hit
    std::vector<std::vector<std::vector<double> > > dtime; //Time difference

    //Information of simulated hit pattern
    std::vector<std::vector<int> > pixel_hit;
    std::vector<std::vector<double> > tdc_time;

    //Information of primary particle
    std::vector<double> x0,y0,px,py,pz,p;
    std::vector<double> theta,phi;
    std::vector<double> t;

    std::vector<std::vector<double > > mean_time;
    std::vector<std::vector<double > > deviation_time;

    //Creating matrix for hitpattern
    for(int nparticle = 0; nparticle < particles; nparticle++)
    {
        pixel_prediction.push_back(std::vector<std::vector<int> >());
        time_prediction.push_back(std::vector<std::vector<double> >());
        dtime.push_back(std::vector<std::vector<double> >());
        mean_time.push_back(std::vector<double>());
        deviation_time.push_back(std::vector<double>());
        pixel_hit.push_back(std::vector<int>());
        tdc_time.push_back(std::vector<double>());

        for(int nhypo = 0; nhypo < 3; nhypo++)
        {
            pixel_prediction[nparticle].push_back(std::vector<int>());
            time_prediction[nparticle].push_back(std::vector<double>());
            dtime[nparticle].push_back(std::vector<double>());
        }
    }

    for(int i = 0; i < particles; i++)
    {
        PndDiscParticleMCPoint* particle_mc_point = (PndDiscParticleMCPoint*)tclarr_particles_in->At(i);

        double time = particle_mc_point->GetTime();

        t.push_back(time);
    }

    for(int i = 0; i < entries; i++)
    {
        PndDiscReconResult* recon_result = (PndDiscReconResult*)tclarr_recon_results->At(i);

        int particle = recon_result->particle;
        int hypothesis = recon_result->hypothesis;
        int pixel = recon_result->pixel;
        double time = recon_result->time;

        pixel_prediction[particle][hypothesis].push_back(pixel);
        time_prediction[particle][hypothesis].push_back(time);
    }

    //-------------------------------------------------------------------------
    // Difference between predicted and simulated time
    //-------------------------------------------------------------------------

    for(int i = 0; i < particles; i++)
    {
        for(int j = 0; j < digits; j++)
        {
            PndDiscDigitizedHit* sensor_mc_point =  (PndDiscDigitizedHit*)tclarr_digits->At(j);

            int detector_id = sensor_mc_point->GetDetectorID();
            int sensor_id = 27*detector_id + sensor_mc_point->GetReadoutID(); //Sensor ID of hit
            //int pixel = sensor_mc_point->GetPixelNumber(); // Pixel number of hit //[R.K. 01/2017] unused variable?
            double tdc = sensor_mc_point->GetTdcTime();

            for(int k = 0; k < 3; k++)
            {
                double propagation = tdc - t[i]; //Calculation of photon propagation time
                double dt = propagation - time_prediction[i][k][sensor_id]; //Calculation of time difference
                if(dt < 3 && dt > -3)
                {
                    dtime[i][k].push_back(dt);
                }
                else
                {
                    dtime[i][k].push_back(-1);
                }
            }
        }

        //Calculating mean of time difference and standard deviation
        for(int k = 0; k < 3; k++)
        {
            mean_time[i].push_back(mean(dtime[i][k]));
            deviation_time[i].push_back(deviation(mean_time[i][k],dtime[i][k]));
            std::cout << "Mean time difference: " << mean_time[i][k] << ", deviation: " << deviation_time[i][k] << std::endl;
        }
        std::cout << std::endl;
    }

    PndDiscPID *pid_result = new PndDiscPID();

    for(int i = 0; i < particles; i++)
    {
        double prob[3] = {0};

        for(int j = 0; j < digits; j++)
        {
            PndDiscDigitizedHit* sensor_mc_point =  (PndDiscDigitizedHit*)tclarr_digits->At(j);

            int detector_id = sensor_mc_point->GetDetectorID();
            int sensor_id = 27*detector_id + sensor_mc_point->GetReadoutID(); //Sensor ID of hit
            int pixel = sensor_mc_point->GetPixelNumber(); // Pixel number of hit
            //double tdc = sensor_mc_point->GetTdcTime(); //[R.K. 01/2017] unused variable?

            for(int k = 0; k < 3; k++)
            {
                //std::cout << "Time differences: " << tdc - t[i] - time_prediction[i][k][sensor_id] - mean_time[i][k] << std::endl;
                //std::cout << "Pixel difference: " << pixel_prediction[i][k][sensor_id] - pixel << std::endl;

                if(pixel_prediction[i][0][sensor_id] != -1 && dtime[i][0][j] != -1 && pixel_prediction[i][1][sensor_id] != -1 && dtime[i][1][j] != -1 && pixel_prediction[i][2][sensor_id] != -1 && dtime[i][2][j] != -1)
                {
                    if((pixel - pixel_prediction[i][0][sensor_id] < 5 && pixel - pixel_prediction[i][0][sensor_id] > -5) || (pixel - pixel_prediction[i][1][sensor_id] < 5 && pixel - pixel_prediction[i][1][sensor_id] > -5) || (pixel - pixel_prediction[i][2][sensor_id] < 5 && pixel - pixel_prediction[i][2][sensor_id] > -5))
                    {
                        //double propagation = tdc - t[i]; //Calculation of photon propagation time //[R.K. 01/2017] unused variable
                        //double dt = propagation - time_prediction[i][k][sensor_id]; //Calculation of time difference //[R.K. 01/2017] unused variable?
                        prob[k] += log(gauss(pixel,pixel_prediction[i][k][sensor_id],4)); //Likelihood calculation
                    }
                }
            }
        }

        std::cout << std::endl;
        std::cout << "Log Likelihood: " << std::endl;
        std::cout << "Pion: " << (prob[0]) << std::endl;
        std::cout << "Kaon: " << (prob[1]) << std::endl;
        std::cout << "Proton: " << (prob[2]) << std::endl << std::endl;

        pid_result->loglikepion = prob[0];
        pid_result->loglikekaon = prob[1];
        pid_result->loglikeproton = prob[2];

        //Save identified particle

        if(prob[0] < prob[1] && prob[0] < prob[2])
        {
            pid_result->pion = 1;
            pid_result->kaon = 0;
            pid_result->proton = 0;
            new ((*tclarr_pid_results)[tclarr_pid_results->GetEntriesFast()]) PndDiscPID(*pid_result);
        }
        if(prob[1] < prob[0] && prob[1] < prob[2])
        {
            pid_result->pion = 0;
            pid_result->kaon = 1;
            pid_result->proton = 0;
            new ((*tclarr_pid_results)[tclarr_pid_results->GetEntriesFast()]) PndDiscPID(*pid_result);
        }
        if(prob[2] < prob[0] && prob[2] < prob[1])
        {
            pid_result->pion = 0;
            pid_result->kaon = 0;
            pid_result->proton = 1;
            new ((*tclarr_pid_results)[tclarr_pid_results->GetEntriesFast()]) PndDiscPID(*pid_result);
        }

    }

    std::cout << "PndDiscTaskPID::Exec" << std::endl;
}

void PndDiscTaskPID::FinishEvent ( )

virtual

Definition at line 326 of file PndDiscTaskPID.cxx.

References tclarr_pid_results.

{
  // called after all Tasks did their Exec() and the data is copied to the file

    if(tclarr_pid_results != NULL) tclarr_pid_results->Clear();

    FinishEvents();
}

void PndDiscTaskPID::FinishTask ( )

virtual

Definition at line 336 of file PndDiscTaskPID.cxx.

{
}

double PndDiscTaskPID::gauss ( int  x, double  mean, double  rms  )

protected

Definition at line 29 of file PndDiscTaskPID.cxx.

References exp(), Pi, and sqrt().

Referenced by Exec().

{
    return 1/sqrt(2*TMath::Pi()*rms*rms)*exp(-0.5*((x-mean_value)/rms)*((x-mean_value)/rms));
}

Bool_t PndPersistencyTask::GetPersistency ( )

inlineinherited

Definition at line 32 of file PndPersistencyTask.h.

References PndPersistencyTask::fPersistency.

Referenced by PndLmdPixelHitProducerFast::GetPersistance(), PndMdtDigitization::Init(), PndMdtHitProducerIdeal::Init(), PndMdtClusterTask::Init(), PndFtsHitProducerRealFast::Init(), PndSttHitProducerRealFast::Init(), PndDiscTaskReconstruction::Init(), PndRichHitProducer::Init(), PndSttHelixHitProducer::Init(), Init(), PndIdealTrackFinder::Init(), PndSttMvdGemTracking::Init(), PndMdtTrkProducer::Init(), PndFtsHitProducerRealFull::Init(), PndLmdPixelClusterTask::Init(), PndSttHitProducerRealFull::Init(), PndLmdStripClusterTask::Init(), PndEmcApdHitProducer::Init(), PndMissingPzCleanerTask::Init(), PndEmcMakeRecoHit::Init(), PndEmcMakeClusterOnline::Init(), PndTrackSmearTask::Init(), PndEmcFWEndcapTimebasedWaveforms::Init(), PndSttHitProducerIdeal::Init(), PndEmcFWEndcapDigi::Init(), PndFtsHitProducerIdeal::Init(), PndEmcMakeCluster::Init(), PndMdtPointsToWaveform::Init(), PndDiscTaskDigitization::Init(), PndEmcMakeDigi::Init(), PndSdsTimeWalkCorrTask::Init(), PndLmdPixelHitProducerFast::Init(), PndDrcHitFinder::Init(), PndRichHitFinder::Init(), PndEmcMakeCorr::Init(), PndFtofHitProducerIdeal::Init(), PndEmcHitsToWaveform::Init(), PndSciTDigiTask::Init(), PndDrcHitProducerIdeal::Init(), PndSdsHitProducerIdeal::Init(), PndSciTHitProducerIdeal::Init(), PndEmcHitProducer::Init(), PndRecoMultiKalmanTask2::Init(), PndDrcHitProducerReal::Init(), PndDskFLGHitProducerIdeal::Init(), PndEmcTmpWaveformToDigi::Init(), PndDrcDigiTask::Init(), PndEmcWaveformToDigi::Init(), PndSttMatchTracks::Init(), PndEmcWaveformToCalibratedDigi::Init(), PndTrkTracking2::Init(), PndSttFindTracks::Init(), PndEmcMultiWaveformToCalibratedDigi::Init(), PndDrcTimeDigiTask::Init(), PndRecoKalmanTask2::Init(), PndEmcExpClusterSplitter::Init(), PndSdsNoiseProducer::Init(), PndFtsHoughTrackerTask::Init(), PndEmcPhiBumpSplitter::Init(), PndSdsHybridHitProducer::Init(), PndSdsIdealRecoTask::Init(), PndRecoMultiKalmanTask::Init(), PndSdsIdealClusterTask::Init(), PndRecoKalmanTask::Init(), PndSdsStripHitProducerDif::Init(), PndSdsStripHitProducer::Init(), PndGemDigitize::Init(), PndGemFindHits::Init(), PndSdsPixelClusterTask::Init(), PndSdsStripClusterTask::Init(), PndMvdGemTrackFinderOnHits::Init(), PndBarrelTrackFinder::Init(), PndEmcFullDigiTask::PndEmcFullDigiTask(), PndEmcMakeBump::PndEmcMakeBump(), PndUnassignedHitsTask::RegisterBranches(), PndMvdClusterTask::SetPersistance(), PndMvdDigiTask::SetPersistance(), PndEmcMakeBump::SetStorageOfData(), and PndEmcFullDigiTask::StoreDigi().

{ return fPersistency; }

InitStatus PndDiscTaskPID::Init ( )

virtual

Definition at line 93 of file PndDiscTaskPID.cxx.

References branch_name_digits, PndPersistencyTask::GetPersistency(), tclarr_digits, tclarr_particles_in, tclarr_pid_results, and tclarr_recon_results.

{
    LOG(INFO) << "PndDiscTaskPID::Init()";

    // Get IO manager instance
    FairRootManager* io_manager = FairRootManager::Instance();
    if(!io_manager)
    {
        LOG(FATAL) << "FairRootManager instance is NULL !!!";
        return kFATAL;
    }

    // Get branch with digitized hits
    tclarr_digits = (TClonesArray*) io_manager->GetObject("DiscDigitizedHit");
    if(!tclarr_digits)
    {
        LOG(ERROR) << "Branch " << branch_name_digits.Data() << " is not accessible through FairRootManager.";
        return kERROR;
    }

    // Get branch with hit pattern prediction
    tclarr_recon_results = (TClonesArray*) io_manager->GetObject("DiscPatternPrediction");
    if(!tclarr_recon_results)
    {
        LOG(ERROR) << "No DiscPatternPrediction collection registered with FairRootManager";
        return kFATAL;
    }

    // Get branch with primary particle information
    tclarr_particles_in = (TClonesArray*) io_manager->GetObject("DiscRealTracks");
    if(!tclarr_particles_in)
    {
        LOG(ERROR) << "No DiscRealTracks collection registered with FairRootManager";
        return kFATAL;
    }

    tclarr_pid_results = new TClonesArray("PndDiscPID");

    io_manager->Register("DiscPID",
                         "DiscDIRC_Detector",
                         tclarr_pid_results, GetPersistency());



    static bool recon_initialized = false;
    if(recon_initialized) return kSUCCESS;

    return kSUCCESS;
}

double PndDiscTaskPID::mean ( std::vector< double >  values )

protected

Definition at line 36 of file PndDiscTaskPID.cxx.

References i.

Referenced by Exec().

{
    double average = 0;

    for(size_t i = 0; i < values.size(); i++)
    {
        average += values[i];
    }

    return average/double(values.size());
}

InitStatus PndDiscTaskPID::ReInit ( )

virtual

Definition at line 85 of file PndDiscTaskPID.cxx.

{
    LOG(INFO) << "PndDiscTaskPID::ReInit()";
    return kSUCCESS;
}

void PndDiscTaskPID::RunTimeBased ( Bool_t  time_based )

inline

Definition at line 38 of file PndDiscTaskPID.h.

References is_time_based.

{ is_time_based = time_based; }

void PndPersistencyTask::SetPersistency ( Bool_t  val = kTRUE )

inlineinherited

Definition at line 31 of file PndPersistencyTask.h.

References PndPersistencyTask::fPersistency, and val.

Referenced by barrelTrackFinder(), digi_complete(), digi_complete_newSTT(), digiOnly_complete(), PndBarrelTrackFinder::PndBarrelTrackFinder(), PndCATracking::PndCATracking(), PndDrcHitFinder::PndDrcHitFinder(), PndEmc2DLocMaxFinder::PndEmc2DLocMaxFinder(), PndEmcExpClusterSplitter::PndEmcExpClusterSplitter(), PndEmcFullDigiTask::PndEmcFullDigiTask(), PndEmcFWEndcapDigi::PndEmcFWEndcapDigi(), PndEmcFWEndcapTimebasedWaveforms::PndEmcFWEndcapTimebasedWaveforms(), PndEmcHitProducer::PndEmcHitProducer(), PndEmcHitsToWaveform::PndEmcHitsToWaveform(), PndEmcMakeBump::PndEmcMakeBump(), PndEmcMakeCluster::PndEmcMakeCluster(), PndEmcMakeClusterOnline::PndEmcMakeClusterOnline(), PndEmcMakeDigi::PndEmcMakeDigi(), PndEmcMakeRecoHit::PndEmcMakeRecoHit(), PndEmcMultiWaveformToCalibratedDigi::PndEmcMultiWaveformToCalibratedDigi(), PndEmcPhiBumpSplitter::PndEmcPhiBumpSplitter(), PndEmcTmpWaveformToDigi::PndEmcTmpWaveformToDigi(), PndEmcWaveformToCalibratedDigi::PndEmcWaveformToCalibratedDigi(), PndEmcWaveformToDigi::PndEmcWaveformToDigi(), PndFtofHitProducerIdeal::PndFtofHitProducerIdeal(), PndFtsCATracking::PndFtsCATracking(), PndFtsHitProducerIdeal::PndFtsHitProducerIdeal(), PndFtsHitProducerRealFast::PndFtsHitProducerRealFast(), PndFtsHitProducerRealFull::PndFtsHitProducerRealFull(), PndFtsHoughTrackerTask::PndFtsHoughTrackerTask(), PndGemDigitize::PndGemDigitize(), PndGemFindHits::PndGemFindHits(), PndIdealTrackFinder::PndIdealTrackFinder(), PndLmdPixelClusterTask::PndLmdPixelClusterTask(), PndLmdPixelHitProducerFast::PndLmdPixelHitProducerFast(), PndMdtClusterTask::PndMdtClusterTask(), PndMdtDigitization::PndMdtDigitization(), PndMdtHitProducerIdeal::PndMdtHitProducerIdeal(), PndMdtPointsToWaveform::PndMdtPointsToWaveform(), PndMdtTrkProducer::PndMdtTrkProducer(), PndMissingPzCleanerTask::PndMissingPzCleanerTask(), PndMvdGemTrackFinderOnHits::PndMvdGemTrackFinderOnHits(), PndMvdHitProducerIdeal::PndMvdHitProducerIdeal(), PndMvdPixelClusterTask::PndMvdPixelClusterTask(), PndMvdTimeWalkCorrTask::PndMvdTimeWalkCorrTask(), PndMvdToPix4ClusterTask::PndMvdToPix4ClusterTask(), PndRecoKalmanTask::PndRecoKalmanTask(), PndRecoKalmanTask2::PndRecoKalmanTask2(), PndRecoMultiKalmanTask::PndRecoMultiKalmanTask(), PndRecoMultiKalmanTask2::PndRecoMultiKalmanTask2(), PndRichHitFinder::PndRichHitFinder(), PndRichHitProducer::PndRichHitProducer(), PndSciTDigiTask::PndSciTDigiTask(), PndSciTHitProducerIdeal::PndSciTHitProducerIdeal(), PndSdsHitProducerIdeal::PndSdsHitProducerIdeal(), PndSdsHybridHitProducer::PndSdsHybridHitProducer(), PndSdsIdealClusterTask::PndSdsIdealClusterTask(), PndSdsIdealRecoTask::PndSdsIdealRecoTask(), PndSdsNoiseProducer::PndSdsNoiseProducer(), PndSdsPixelClusterTask::PndSdsPixelClusterTask(), PndSdsStripClusterTask::PndSdsStripClusterTask(), PndSdsStripHitProducer::PndSdsStripHitProducer(), PndSdsTimeWalkCorrTask::PndSdsTimeWalkCorrTask(), PndSttFindTracks::PndSttFindTracks(), PndSttHelixHitProducer::PndSttHelixHitProducer(), PndSttHitProducerIdeal::PndSttHitProducerIdeal(), PndSttHitProducerRealFast::PndSttHitProducerRealFast(), PndSttHitProducerRealFull::PndSttHitProducerRealFull(), PndSttMatchTracks::PndSttMatchTracks(), PndSttMvdGemTracking::PndSttMvdGemTracking(), PndTrackSmearTask::PndTrackSmearTask(), PndTrkTracking2::PndTrkTracking2(), reco(), reco_complete(), reco_complete_gf2(), reco_complete_newSTT(), reco_complete_sec(), recoideal_complete(), PndMvdClusterTask::SetPersistance(), PndMvdDigiTask::SetPersistance(), PndLmdPixelHitProducerFast::SetPersistance(), PndSdsHitProducerIdeal::SetPersistance(), PndSttMvdGemTracking::SetPersistenc(), PndMdtClusterTask::SetPersistence(), PndSttHelixHitProducer::SetPersistence(), PndMissingPzCleanerTask::SetPersistence(), PndFtsHitProducerRealFast::SetPersistence(), PndFtsHitProducerRealFull::SetPersistence(), PndSttHitProducerIdeal::SetPersistence(), PndSttHitProducerRealFull::SetPersistence(), PndSttHitProducerRealFast::SetPersistence(), PndFtsHitProducerIdeal::SetPersistence(), PndTrackSmearTask::SetPersistence(), PndSciTHitProducerIdeal::SetPersistence(), PndIdealTrackFinder::SetPersistence(), PndSttMatchTracks::SetPersistence(), PndSttFindTracks::SetPersistence(), PndFtsHoughTrackerTask::SetPersistence(), PndTrkTracking2::SetPersistence(), PndEmcMakeRecoHit::SetStorageOfData(), PndEmcMakeClusterOnline::SetStorageOfData(), PndEmcFWEndcapDigi::SetStorageOfData(), PndEmcFWEndcapTimebasedWaveforms::SetStorageOfData(), PndEmcMakeDigi::SetStorageOfData(), PndMdtPointsToWaveform::SetStorageOfData(), PndEmc2DLocMaxFinder::SetStorageOfData(), PndEmcMakeCluster::SetStorageOfData(), PndEmcHitsToWaveform::SetStorageOfData(), PndEmcMakeBump::SetStorageOfData(), PndEmcTmpWaveformToDigi::SetStorageOfData(), PndEmcWaveformToDigi::SetStorageOfData(), PndEmcWaveformToCalibratedDigi::SetStorageOfData(), PndEmcMultiWaveformToCalibratedDigi::SetStorageOfData(), PndEmcExpClusterSplitter::SetStorageOfData(), PndEmcPhiBumpSplitter::SetStorageOfData(), standard_tracking(), and PndEmcFullDigiTask::StoreDigi().

{ fPersistency = val; }

Member Data Documentation

TString PndDiscTaskPID::branch_name_digits

protected

Branch name where digitized hits are stored.

Definition at line 42 of file PndDiscTaskPID.h.

Referenced by Init(), and PndDiscTaskPID().

TString PndDiscTaskPID::folder_name_digits

protected

Folder name for digits.

Definition at line 43 of file PndDiscTaskPID.h.

Referenced by PndDiscTaskPID().

Bool_t PndDiscTaskPID::is_time_based

protected

Time based buffering on/off.

Definition at line 52 of file PndDiscTaskPID.h.

Referenced by RunTimeBased().

TClonesArray* PndDiscTaskPID::tclarr_digits

protected

Definition at line 45 of file PndDiscTaskPID.h.

Referenced by Exec(), and Init().

TClonesArray* PndDiscTaskPID::tclarr_particles_in

protected

Definition at line 47 of file PndDiscTaskPID.h.

Referenced by Exec(), and Init().

TClonesArray* PndDiscTaskPID::tclarr_pid_results

protected

results of reconstruction (pattern matching)

Definition at line 49 of file PndDiscTaskPID.h.

Referenced by Exec(), FinishEvent(), and Init().

TClonesArray* PndDiscTaskPID::tclarr_recon_results

protected

Definition at line 46 of file PndDiscTaskPID.h.

Referenced by Exec(), and Init().

---

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

• PndDiscTaskPID.h
• PndDiscTaskPID.cxx