PndGiBuuGenerator.cxx

Go to the documentation of this file.

// -------------------------------------------------------------------------
// -----                PndGiBuuGenerator source file                  -----
// -------------------------------------------------------------------------


#include <iostream>
#include "PndGiBuuGenerator.h"
#include "FairPrimaryGenerator.h"

// -----   Standard constructor   -----------------------------------------
PndGiBuuGenerator::PndGiBuuGenerator(const Char_t* fileName, const Char_t* pidDataFileName) :
                fEvent(0), fRunId(0), fFileName(fileName), fPidDataFileName(pidDataFileName), fInputAsciiFile(0), fPx(0), fPy(0), fPz(0), fPdg(0)
{
        std::cout << "Constructor Called!" << std::endl;
}
// ------------------------------------------------------------------------


// -----   Destructor   ---------------------------------------------------
PndGiBuuGenerator::~PndGiBuuGenerator() {
  CloseInput();
  for (std::map<Int_t, PndGiBuuDecayerAbs*>::const_iterator iter = fDecayerMap.begin(); iter != fDecayerMap.end(); iter++){
          delete(iter->second);
  }
}
// ------------------------------------------------------------------------

Bool_t PndGiBuuGenerator::Init()
{

        fInputAsciiFile = new std::ifstream(fFileName.Data(), std::ifstream::in);
        if (0 == fInputAsciiFile) {
                Fatal("PndGiBuuGenerator", "Cannot open ASCII input file.");
        }

        FillPidMap();

        return kTRUE;
}

// ------------------------------------------------------------------------



// -----   Public method ReadEvent   --------------------------------------
Bool_t PndGiBuuGenerator::ReadEvent(FairPrimaryGenerator* primGen)
{

        Int_t GiBuuPid = 0, GiBuuCharge = 0;
        //Int_t runId = 0; //[R.K. 01/2017] unused variable?
        Int_t motherId1 = 0;
        Int_t motherId2 = 0;
        Int_t dummyInt = 0;
        Double_t mass = 0.;
        Double_t energy = 0.;
        Int_t oldEventNr = fEvent;
        Int_t oldRunId = fRunId;

        Double_t dummyDouble = 0.;

        std::cout << "ReadEvent: " << fEvent << std::endl;

        if (fEvent > 0){
                WriteoutDecayParticle(oldEventNr, oldRunId, primGen);
        } else {
                oldEventNr = 0;
                oldRunId = 0;
                fEvent = 0;
                fRunId = 0;
        }

        while (fEvent == oldEventNr && !(fInputAsciiFile->eof())){
                *fInputAsciiFile >> GiBuuPid >> GiBuuCharge >> motherId1 >> motherId2 >> dummyInt >> mass >> dummyInt >> energy >> fPx >> fPy >> fPz >> dummyDouble >> fEvent >> fRunId >> dummyDouble;
                if (0 == oldEventNr){
                        oldEventNr = fEvent;
                        oldRunId = fRunId;
                }
                fPdg = GetPdgParticleId(GiBuuPid, GiBuuCharge);
                WriteoutDecayParticle(oldEventNr, oldRunId, primGen);
        }

        return kTRUE;
}

void PndGiBuuGenerator::WriteoutDecayParticle(Int_t oldEventNr, Int_t oldRunId, FairPrimaryGenerator* primGen)
{
        if (fEvent == oldEventNr && fRunId == oldRunId) {
                if (fDecayerMap.count(fPdg) > 0) {
                        std::vector<PndGiBuuTrack> tracks = fDecayerMap[fPdg]->DecayTrack(PndGiBuuTrack(fPdg, fPx, fPy, fPz, 0., 0., 0.));
                        for (size_t i = 0; i < tracks.size(); i++) {
                                std::cout << "Writing decayed particles: " << tracks[i].GetPdgId() << std::endl;
                                primGen->AddTrack(tracks[i].GetPdgId(),
                                                tracks[i].GetMomentum().X(), tracks[i].GetMomentum().Y(), tracks[i].GetMomentum().Z(),
                                                tracks[i].GetVertex().X(), tracks[i].GetVertex().Y(), tracks[i].GetVertex().Z());
                        }
                } else {
                        std::cout << "Writing particle direct: " << fPdg << std::endl;
                        primGen->AddTrack(fPdg, fPx, fPy, fPz, 0., 0., 0.);
                }
        }
}

void PndGiBuuGenerator::FillPidMap()
{
        std::ifstream* PidFile = new std::ifstream(fPidDataFileName.Data(), std::ifstream::in);
        if (0 == PidFile){
                Fatal("PndGiBuuGenerator::FillPidMap", "No pid file!");
        }
        Int_t giPid = 0;
        Int_t giCharge = 0;
        Int_t pdgPid = 0;

//      std::cout << "Reading In PidFile: " << fPidDataFileName.Data() <<  " " << PidFile << " " << PidFile->eof() << std::endl;

        while (!(PidFile->eof())){
                *PidFile >> giPid >> giCharge >> pdgPid;
                std::pair<Int_t, Int_t> GiBuuPid(giPid, giCharge);
                fMapGiBuuToPdg[GiBuuPid] = pdgPid;
//              std::cout << giPid << " " << giCharge << " = " << pdgPid << std::endl;
        }
        PidFile->close();
        PidFile = 0;

}

Int_t PndGiBuuGenerator::GetPdgParticleId(Int_t GiBuuId, Int_t charge)
{
        std::pair<Int_t, Int_t> GiBuuPid(GiBuuId, charge);
        if (fMapGiBuuToPdg.count(GiBuuPid) > 0){
                return fMapGiBuuToPdg[GiBuuPid];
        } else {
                return 0;
        }
}

// -----   Private method CloseInput   ------------------------------------
void PndGiBuuGenerator::CloseInput() {

        fInputAsciiFile->close();
        //delete fInputAsciiFile;
        fInputAsciiFile = NULL;

}
// ------------------------------------------------------------------------



ClassImp(PndGiBuuGenerator)