PndHypIdealPRTask Class Reference

#include <PndHypIdealPRTask.h>

Inheritance diagram for PndHypIdealPRTask:

Public Member Functions
	PndHypIdealPRTask ()
	~PndHypIdealPRTask ()
void	AddHitBranch (unsigned int detId, const TString &m)
void	SetPersistence (Bool_t opt=kTRUE)
virtual InitStatus	Init ()
virtual InitStatus	ReInit ()
virtual void	Exec (Option_t *opt)
void	WriteHistograms ()

Private Member Functions
Int_t	GetChargeIon (Int_t ion)
void	AddHitToTrack (Int_t trackID, Int_t detnum, Int_t iHit)
void	ClearTrackCandMap ()

Private Attributes
TClonesArray *	fHitArray
TClonesArray *	fPointArray
TClonesArray *	fSdsArray
TClonesArray *	fTrackArray
TClonesArray *	fMcArray
Bool_t	fPersistence
std::map< unsigned int, TString >	fHitBranchNameMap
std::map< unsigned int, TClonesArray * >	fHitBranchMap
std::map< Int_t, GFTrackCand * >	fTrackCandMap
int	fEventNr
TH1D *	fPH
GFRecoHitFactory *	fTheRecoHitFactory

Detailed Description

Definition at line 47 of file PndHypIdealPRTask.h.

Constructor & Destructor Documentation

PndHypIdealPRTask::PndHypIdealPRTask

(

)

Definition at line 49 of file PndHypIdealPRTask.cxx.

  : FairTask("Ideal Pattern Reco"),  fPersistence(kFALSE),fEventNr(0)
{
}

PndHypIdealPRTask::~PndHypIdealPRTask

(

)

Definition at line 55 of file PndHypIdealPRTask.cxx.

References fPH.

{
 if(fPH!=NULL)delete fPH;
}

Member Function Documentation

void PndHypIdealPRTask::AddHitBranch ( unsigned int  detId, const TString &  m  )

inline

Definition at line 59 of file PndHypIdealPRTask.h.

References fHitBranchNameMap, and m.

{fHitBranchNameMap[detId]=m;};

void PndHypIdealPRTask::AddHitToTrack ( Int_t  trackID, Int_t  detnum, Int_t  iHit  )

private

Definition at line 228 of file PndHypIdealPRTask.cxx.

References fMcArray, fTrackCandMap, GetChargeIon(), PndMCTrack::GetMomentum(), PndMCTrack::GetPdgCode(), PndMCTrack::GetStartVertex(), GFTrackCand::setMcTrackId(), GFTrackCand::setPdgCode(), and GFTrackCand::setTrackSeed().

Referenced by Exec().

                                                 {
  
  if(fTrackCandMap[trackID]==NULL){
    // create new track
    //std::cout<<"Creating new track candidate with id="<<id<<std::endl;

    GFTrackCand *myTCand=new GFTrackCand();
    
    // Get MCTrack
    PndMCTrack* mc=(PndMCTrack*)fMcArray->At(trackID);
    
    
    int pdg=mc->GetPdgCode();
    double q;
    int PDG;
    
    std::cout<<" particle "<<pdg<<std::endl;
    
    
    if(pdg>5000){
       q = GetChargeIon(pdg);
      //std::cout<<" particle "<<q<<std::endl;
    }
    else { q=TDatabasePDG::Instance()->GetParticle(pdg)->Charge()/3.;
      //std::cout<<" particle "<<q<<std::endl;
    }
    
    myTCand->setTrackSeed(
                          mc->GetStartVertex(),
                          mc->GetMomentum(),
                          q/mc->GetMomentum().Mag()
                          );
    
    
     myTCand->setMcTrackId(trackID);
     myTCand->setPdgCode(pdg);
     fTrackCandMap[trackID]= myTCand;

  }
  // add hit to track
  // set detectorid=2;
  fTrackCandMap[trackID]->addHit(detnum,iHit);
  
  
}

void PndHypIdealPRTask::ClearTrackCandMap ( )

private

Definition at line 304 of file PndHypIdealPRTask.cxx.

References fTrackCandMap.

Referenced by Exec().

{
  for (std::map<Int_t,GFTrackCand*>::const_iterator ci=fTrackCandMap.begin();
          ci != fTrackCandMap.end(); ci++){
    delete(ci->second);
  }
  fTrackCandMap.clear();
}

void PndHypIdealPRTask::Exec ( Option_t *  opt )

virtual

Virtual method Exec

Definition at line 131 of file PndHypIdealPRTask.cxx.

References AddHitToTrack(), ClearTrackCandMap(), fEventNr, fHitArray, fHitBranchMap, fMcArray, fPH, fPointArray, fSdsArray, fTrackArray, fTrackCandMap, GFTrackCand::getHit(), GFTrackCand::getNHits(), hit, and point.

{
  std::cout<<"PndHypIdealPRTask::Exec"<<std::endl;
  // Reset output Array
  if(fTrackArray==0) Fatal("PndHypIdealPR::Exec)","No TrackArray");
   fTrackArray->Delete();

   // use McId to distinguish data from different tracks
   //std::map<unsigned int,GFTrackCand*> candmap;
   std::cout<<"<<<<< Event "<<fEventNr++<<" <<<"<<std::endl;
   

   std::map<unsigned int,TClonesArray*>::iterator iter=fHitBranchMap.begin();
   while(iter!=fHitBranchMap.end()){
     
     fHitArray = iter->second;
     //loop over points
     Int_t np=fHitArray->GetEntriesFast();
     FairMCPoint* point;
     FairHit* hit;

     for(Int_t ip=0; ip<np; ++ip){
       
       if(iter->first==2){
         hit = (PndHypHit*)fHitArray->At(ip);

         point = (PndHypPoint*)fPointArray->At(hit->GetRefIndex());
       }
       else if(iter->first==3){
         hit = (PndSdsHit*)fHitArray->At(ip);
         point = (PndSdsMCPoint*)fSdsArray->At(hit->GetRefIndex());
       }
       if(point==0)continue;
       
       unsigned int id=point->GetTrackID();
       // cut on insane ids
       if(id>10000)continue;
       // look for track in mc map
       AddHitToTrack(id,iter->first,ip);

       /* if(candmap[id]==NULL){
         // create new track
         //std::cout<<"Creating new track candidate with id="<<id<<std::endl;
         candmap[id]=new GFTrackCand;
       }
       // add hit to track
       // set detectorid=2;
       candmap[id]->addHit(iter->first,ip);
       */
     }// end loop over cluster
       
     ++iter;
   }

   // ------------------------------------------------------------------------
   // try to find some starting values
   // loop over tracks
   
   std::map<Int_t ,GFTrackCand*>::iterator candIter=fTrackCandMap.begin();
   while(candIter!=fTrackCandMap.end()){
     GFTrackCand* cand=candIter->second;
     if(cand->getNHits()<3){
       ++candIter;
       continue;
     }
     TVector3 frmom;
     unsigned int detId, hitId;
     cand->getHit(0, detId, hitId);
     PndHypHit* myHit; 
     myHit = (PndHypHit*)fHitArray->At(hitId);
     FairMCPoint* pointF;
     
     if(detId==2)   pointF =(FairMCPoint*)fPointArray->At(myHit->GetRefIndex());
     std::cout << "Detector no. " << detId <<": "<< *pointF;
     pointF->Momentum(frmom);
     fPH->Fill(frmom.Mag());
     

     // create track object
     
     new((*fTrackArray)[fTrackArray->GetEntriesFast()]) GFTrackCand(*(candIter->second));
    

     ++candIter;
   }// end loop over tracks
   
   std::cout<<fTrackArray->GetEntriesFast()<<" tracks created "<<std::endl;
    
  ClearTrackCandMap();
  fHitArray->Delete();  
  fMcArray->Delete();
  
 
   
   //return;
}

Int_t PndHypIdealPRTask::GetChargeIon ( Int_t  ion )

private

Definition at line 275 of file PndHypIdealPRTask.cxx.

References L, and Z.

Referenced by AddHitToTrack().

{
  Int_t A,Z,L;
  
  if(ion>1000000000&&(ion<1010000000))
    { ion -= 1000000000;
      Z = ion/10000;
      ion -= 10000*Z;
      A = ion/10;
      cout<<" ion charge "<<Z<<endl;
      
      return Z;
      
    }
if((ion>1010000000||ion>1020000000))
  { 
    ion -= 1000000000;
    L = ion/10000000;
    ion -= 10000000*L;
    Z = ion/10000;
    ion -= 10000*Z;
    A = ion/10;
    cout<<L<<" hypernuclei charge "<<Z<<endl;
    
    return Z;
  
  }
}

InitStatus PndHypIdealPRTask::Init ( )

virtual

Virtual method Init

Definition at line 69 of file PndHypIdealPRTask.cxx.

References fHitBranchMap, fHitBranchNameMap, fMcArray, fPersistence, fPH, fPointArray, fSdsArray, and fTrackArray.

{
  //Get ROOT Manager
  FairRootManager* ioman= FairRootManager::Instance();

  if(ioman==0)
    {
      Error("PndHypIdealPRTask::Init","RootManager not instantiated!");
      return kERROR;
    }
 
  // open hit arrays
  std::map<unsigned int,TString>::iterator iter=fHitBranchNameMap.begin();
  while(iter!=fHitBranchNameMap.end()){
   TClonesArray* ar=(TClonesArray*) ioman->GetObject(iter->second);
   if(ar==0){
     Error("PndHypDPRTask::Init","point-array %s not found!",iter->second.Data());
   }
   else{ 
         fHitBranchMap[iter->first] = ar;
   }
  ++iter;
  }//end loops over hit types
  

  // open MCTruth array
  fMcArray=(TClonesArray*) ioman->GetObject("MCTrack");
  if(fMcArray==0){
    Error("PndHypDPRTask::Init","mctrack-array not found!");
    return kERROR;
  }
   
  fPointArray=(TClonesArray*) ioman->GetObject("HypPoint");
  if(fPointArray==0){
    Error("PndHypDPRTask::Init","hyp hit-array not found!");
    return kERROR;
    }

  fSdsArray=(TClonesArray*) ioman->GetObject("MVDPoint");
  if(fSdsArray==0){
    Error("PndHypDPRTask::Init","mvd hit-array not found!");
    return kERROR;
    }
  

  // create and register output array
  fTrackArray = new TClonesArray("GFTrackCand"); 
  ioman->Register("HypTrackCand","HYP",fTrackArray,fPersistence);
 
  
 // setup histograms
   fPH=new TH1D("pH","p",1000,0.02,0.3);
  

  std::cout << "-I- PndHypIdealPRTask: Initialisation successfull" << std::endl;
  
  
  return kSUCCESS;
}

InitStatus PndHypIdealPRTask::ReInit ( )

virtual

Definition at line 60 of file PndHypIdealPRTask.cxx.

{
  
  InitStatus stat=kERROR;
  return stat;
 
}

void PndHypIdealPRTask::SetPersistence ( Bool_t  opt = kTRUE )

inline

Definition at line 60 of file PndHypIdealPRTask.h.

References fPersistence.

{fPersistence=opt;}

void PndHypIdealPRTask::WriteHistograms

(

)

Definition at line 314 of file PndHypIdealPRTask.cxx.

References file, and fPH.

                                       {
  TFile* file = FairRootManager::Instance()->GetOutFile();
  file->cd();
  file->mkdir("HypPrefit");
  file->cd("HypPrefit");
 
  
  fPH->Write();
  delete fPH;
  fPH=NULL;

  file->Close();
  delete file;

}

Member Data Documentation

int PndHypIdealPRTask::fEventNr

private

Definition at line 91 of file PndHypIdealPRTask.h.

Referenced by Exec().

TClonesArray* PndHypIdealPRTask::fHitArray

private

Definition at line 79 of file PndHypIdealPRTask.h.

Referenced by Exec().

std::map<unsigned int,TClonesArray*> PndHypIdealPRTask::fHitBranchMap

private

Definition at line 89 of file PndHypIdealPRTask.h.

Referenced by Exec(), and Init().

std::map<unsigned int,TString> PndHypIdealPRTask::fHitBranchNameMap

private

Definition at line 88 of file PndHypIdealPRTask.h.

Referenced by AddHitBranch(), and Init().

TClonesArray* PndHypIdealPRTask::fMcArray

private

Definition at line 83 of file PndHypIdealPRTask.h.

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

Bool_t PndHypIdealPRTask::fPersistence

private

Definition at line 85 of file PndHypIdealPRTask.h.

Referenced by Init(), and SetPersistence().

TH1D* PndHypIdealPRTask::fPH

private

Definition at line 92 of file PndHypIdealPRTask.h.

Referenced by Exec(), Init(), WriteHistograms(), and ~PndHypIdealPRTask().

TClonesArray* PndHypIdealPRTask::fPointArray

private

Definition at line 80 of file PndHypIdealPRTask.h.

Referenced by Exec(), and Init().

TClonesArray* PndHypIdealPRTask::fSdsArray

private

Definition at line 81 of file PndHypIdealPRTask.h.

Referenced by Exec(), and Init().

GFRecoHitFactory* PndHypIdealPRTask::fTheRecoHitFactory

private

Definition at line 97 of file PndHypIdealPRTask.h.

TClonesArray* PndHypIdealPRTask::fTrackArray

private

Definition at line 82 of file PndHypIdealPRTask.h.

Referenced by Exec(), and Init().

std::map<Int_t, GFTrackCand*> PndHypIdealPRTask::fTrackCandMap

private

Definition at line 90 of file PndHypIdealPRTask.h.

Referenced by AddHitToTrack(), ClearTrackCandMap(), and Exec().

---

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

• PndHypIdealPRTask.h
• PndHypIdealPRTask.cxx