EdbScanTracking Class Reference

#include <EdbScanTracking.h>

Inheritance diagram for EdbScanTracking:

Collaboration diagram for EdbScanTracking:

Public Member Functions
	EdbScanTracking ()
void	SaveHist (EdbID idset, EdbTrackAssembler &etra)
void	SetPredictionAng (const char *str)
void	SetPredictionXY (const char *str)
void	SetPredictionZ (const char *str)
void	TrackAli (EdbPVRec &ali, TEnv &env)
void	TrackSetBT (EdbID id, TEnv &env, Int_t ix=-1, Int_t iy=-1)
virtual	~EdbScanTracking ()

Public Attributes
bool	eDoRealign
int	eNgapMax
int	eNsegMin
PredictionCut	ePRC
EdbScanProc *	eSproc

Constructor & Destructor Documentation

EdbScanTracking()

EdbScanTracking::EdbScanTracking

(

)

{
  eNsegMin=2;
  eNgapMax=50;
  ePRC.doXY=0;
  ePRC.doAng=0;
  ePRC.doZ=0;
}

~EdbScanTracking()

virtual EdbScanTracking::~EdbScanTracking ( )

inlinevirtual

{}

Member Function Documentation

SaveHist()

void EdbScanTracking::SaveHist	(	EdbID	idset,
		EdbTrackAssembler &	etra
	)

{
  TFile f( Form("b%s.trk.root", idset.AsString()) ,"UPDATE");
  if(etra.eHistNcnd) etra.eHistNcnd->Write();
  if(etra.eHistProbAll) etra.eHistProbAll->Write();
  if(etra.eHistProbBest) etra.eHistProbBest->Write();
  if(etra.eHistXYseg)    etra.eHistXYseg->Write();
  if(etra.eHistXYPseg)   etra.eHistXYPseg->Write();
  if(etra.eHistXYPsegNB) etra.eHistXYPsegNB->Write();
  if(etra.eHistTXTYseg)  etra.eHistTXTYseg->Write();
  TH1F *probrest = 0, *probPurity=0;
  if(etra.eHistProbAll&&etra.eHistProbBest) {
    probrest = (TH1F*)(etra.eHistProbAll->Clone("ProbRest"));
    probrest->SetTitle("prob for the other candidates");
    probrest->Add(etra.eHistProbBest,-1);
    probrest->Write();
    probPurity = (TH1F*)(probrest->Clone("ProbPurity"));
    probPurity->SetTitle("Nother/Nall vs prob");
    probPurity->Divide(etra.eHistProbAll);
    probPurity->Write();
  }
  if(etra.eHistThetaAll) etra.eHistThetaAll->Write();
  if(etra.eHistThetaBest) etra.eHistThetaBest->Write();
  TH1F *thetarest = 0, *thetaPurity=0;
  if(etra.eHistThetaAll&&etra.eHistThetaBest) {
    thetarest = (TH1F*)(etra.eHistThetaAll->Clone("ThetaRest"));
    thetarest->SetTitle("theta for other candidates");
    thetarest->Add(etra.eHistThetaBest,-1);
    thetarest->Write();
    thetaPurity = (TH1F*)(thetarest->Clone("ThetaPurity"));
    thetaPurity->SetTitle("Nother/Nall vs theta");
    thetaPurity->Divide(etra.eHistThetaAll);
    thetaPurity->Write();
  }
  
  gStyle->SetPalette(1);
  gStyle->SetOptStat(1);
  bool batch = gROOT->IsBatch();
  gROOT->SetBatch();
  
  TCanvas *c = new TCanvas("purity","tracking purity",900,800);
  c->Divide(2,3);
 
  c->cd(1)->SetLogy(); 
  etra.eHistNcnd->SetAxisRange(0,10);
  etra.eHistNcnd->Draw();
 
  c->cd(2); probrest->SetLineColor(kBlue); probrest->Draw();
 
  c->cd(3)->SetLogy();
  etra.eHistProbAll->Draw();
  etra.eHistProbBest->SetLineColor(kRed); etra.eHistProbBest->Draw("same");
  probrest->SetLineColor(kBlue); probrest->Draw("same");
 
  c->cd(5);
  probPurity->Draw();
 
  c->cd(4)->SetLogy();
  etra.eHistThetaAll->Draw();
  etra.eHistThetaBest->SetLineColor(kRed); etra.eHistThetaBest->Draw("same");
  thetarest->SetLineColor(kBlue); thetarest->Draw("same");
 
  c->cd(6);
  thetaPurity->Draw();
 
  c->Write();
  SafeDelete(c);
  gROOT->SetBatch(batch);
  f.Close();
}

SetPredictionAng()

void EdbScanTracking::SetPredictionAng

(

const char *

str

)

{
 sscanf(str,"%d %f %f %f %f", &ePRC.doAng, &ePRC.tx, &ePRC.ty, &ePRC.dtx, &ePRC.dty );
}

SetPredictionXY()

void EdbScanTracking::SetPredictionXY

(

const char *

str

)

{
  sscanf(str,"%d %f %f %f %f", &ePRC.doXY, &ePRC.x0, &ePRC.y0, &ePRC.dx,  &ePRC.dy);
}

SetPredictionZ()

void EdbScanTracking::SetPredictionZ

(

const char *

str

)

{
 sscanf(str,"%d %f %f %f %f", &ePRC.doZ, &ePRC.z0, &ePRC.zmin, &ePRC.zmax );
}

TrackAli()

void EdbScanTracking::TrackAli	(	EdbPVRec &	ali,
		TEnv &	env
	)

{
    EdbTrackAssembler etra;
  
    etra.eCond.SetSigma0(        env.GetValue("fedra.track.Sigma0"         , "3 3 0.005 0.005") );
    etra.eCond.SetPulsRamp0(     env.GetValue("fedra.track.PulsRamp0"      , "15 20") );
    etra.eCond.SetPulsRamp04(    env.GetValue("fedra.track.PulsRamp04"     , "15 20") );
    etra.eCond.SetDegrad(        env.GetValue("fedra.track.Degrad"          , 4) );
    etra.eCond.SetRadX0(         env.GetValue("fedra.track.RadX0"          , 5810.) );
    
      
    etra.eDTmax                 = env.GetValue("fedra.track.DTmax"          ,     0.07 );
    etra.eDRmax                 = env.GetValue("fedra.track.DRmax"          ,    45.   );
    etra.eDZGapMax              = env.GetValue("fedra.track.DZGapMax"       ,  5000.   );
    etra.eProbMin               = env.GetValue("fedra.track.probmin"        ,  0.001   );
    
    bool        do_misalign     = env.GetValue("fedra.track.do_misalign"    ,      0   );
    int         npass           = env.GetValue("fedra.track.npass"          ,      1   );
    float       misalign_offset = env.GetValue("fedra.track.misalign_offset",    500.  );
    //bool        do_local_corr   = env.GetValue("fedra.track.do_local_corr"  ,      1   );
    bool        eDoRealign      = env.GetValue("fedra.track.do_realign"     ,      0   );
    bool        do_comb         = env.GetValue("fedra.track.do_comb"        ,      0   );
    eNsegMin                    = env.GetValue("fedra.track.NsegMin"        ,      2   );
    float       momentum        = env.GetValue("fedra.track.momentum",     2. );
    etra.InitTrZMap(  env.GetValue("fedra.track.TrZmap", "2400 0 120000   2000 0 100000   30" ) );
 
    EdbAffine2D misalign[60];
    if(do_misalign) {
        //           1 2 3 4 5 6  7  8  9
      int dx[9] = {0,0,1,1,1,0,-1,-1,-1};
      int dy[9] = {0,1,1,0,-1,-1,-1,0,1};
      for(int i=0; i<60; i++) {
        misalign[i].ShiftX( dx[i%9] * misalign_offset );
        misalign[i].ShiftY( dy[i%9] * misalign_offset );
        if(gEDBDEBUGLEVEL>1) printf("%d |  %d  %d\n",i, dx[i%9], dy[i%9]);
      }
    }
  
    int npl = ali.Npatterns();
  
    // read segments and use them for tracking
    for(int ipass=0; ipass<npass; ipass++) {
      if(gEDBDEBUGLEVEL>1) printf("\n\n*************** ipass=%d ************\n",ipass);
      etra.eCollisionsRate=0;
      for(int i=0; i<npl; i++) {
        
        EdbPattern &p = *ali.GetPattern(i);
        
        //p.SetZ(plate->Z());
        p.SetSegmentsZ();
        p.SetID(i);
        p.SetPID(i);
        p.SetSegmentsPID();
//        p.SetSegmentsPlate(id->ePlate);
        if(gEDBDEBUGLEVEL>1) printf("pattern with z: %f\n", p.Z());
      
        if(do_misalign) {
          p.Transform(&misalign[i]);
          Log(2,"EdbScanTracking::TrackSetBT","apply misalignment of %f",misalign_offset);
        }
  
        if(i>0)
      if(etra.eDoUseMCS==3) etra.ExtrapolateTracksToZ_mcs3(p.Z());
      else                  etra.ExtrapolateTracksToZ(p.Z());
        etra.FillTrZMap();
        etra.AddPattern(p);
      }
    }
 
    int ntr = etra.Tracks().GetEntriesFast();
    
    for(int i=0; i<ntr; i++) {
      EdbTrackP *t = (EdbTrackP *)(etra.Tracks().At(i));
      if(t->N()<eNsegMin)  t->SetFlag(-10);
    }
    
    etra.SetSegmentsErrors();
    etra.FitTracks();
 
    TObjArray selectedTracks(ntr);
    if(do_comb) {
      etra.CombTracks(selectedTracks);
    } else {
      int cnt=0;
      for(int i=0; i<ntr; i++) {
        EdbTrackP *t = (EdbTrackP *)(etra.Tracks().At(i));
        if(t->Flag()!=-10)  {
          t->SetID(cnt++);
          t->SetCounters();
          t->SetSegmentsTrack();
          t->SetP(momentum);
          selectedTracks.Add(t);
        }
      }
    }
    
    EdbID idset;
    EdbDataProc::MakeTracksTree( selectedTracks, 0., 0., Form("b%s.trk.root", idset.AsString()) );
    TFile f( Form("b%s.trk.root", idset.AsString()) ,"UPDATE");
    env.Write();
    f.Close();
    
    SaveHist(idset,etra);
}

TrackSetBT()

void EdbScanTracking::TrackSetBT	(	EdbID	id,
		TEnv &	env,
		Int_t	ix = -1,
		Int_t	iy = -1
	)

{
  
  // read scanset object
  EdbScanSet *ss = eSproc->ReadScanSet(idset);
  if(!ss) { Log(1,"EdbScanTracking::TrackSetBT",
    "Error! set for %s do not found",idset.AsString()); return; }
  
    int npl = ss->eIDS.GetSize();
    if(npl<2) { Log(1,"EdbScanTracking::TrackSetBT", "Warning! npl<2 : %d stop tracking!",npl); return; }
  
  // create and init tracking object
    EdbTrackAssembler etra;
  
    etra.eCond.SetSigma0(        env.GetValue("fedra.track.Sigma0"         , "3 3 0.005 0.005") );
    etra.eCond.SetPulsRamp0(     env.GetValue("fedra.track.PulsRamp0"      , "15 20") );
    etra.eCond.SetPulsRamp04(    env.GetValue("fedra.track.PulsRamp04"     , "15 20") );
    etra.eCond.SetDegrad(        env.GetValue("fedra.track.Degrad"         , 4) );
    etra.SetRadLength(           env.GetValue("fedra.track.RadX0"          , 5810.) );
    etra.eDoUseMCS              = env.GetValue("fedra.track.do_use_mcs"    , 0 );
      
    etra.eDTmax                 = env.GetValue("fedra.track.DTmax"          ,     0.07 );
    etra.eDRmax                 = env.GetValue("fedra.track.DRmax"          ,    45.   );
    etra.eDZGapMax              = env.GetValue("fedra.track.DZGapMax"       ,  5000.   );
    etra.eProbMin               = env.GetValue("fedra.track.probmin"        ,  0.001   );
    bool        do_track        = env.GetValue("fedra.track.do_track"       ,  true    );
    bool        do_erase        = env.GetValue("fedra.track.erase"          ,  false   );
    bool        do_shtag        = env.GetValue("fedra.track.do_shtag"       ,  false   );  // no tracking only shower tag info
    TCut  cut            = env.GetValue("fedra.readCPcut"            ,     "1"  ); //changed from const char* to TCut used by ReadPatCPnopar
    bool        do_misalign     = env.GetValue("fedra.track.do_misalign"    ,      0   );
    int         npass           = env.GetValue("fedra.track.npass"          ,      1   );
    float       misalign_offset = env.GetValue("fedra.track.misalign_offset",    500.  );
    bool        do_local_corr   = env.GetValue("fedra.track.do_local_corr"  ,      1   );
    bool        eDoRealign      = env.GetValue("fedra.track.do_realign"     ,      0   );
    bool        do_comb         = env.GetValue("fedra.track.do_comb"        ,      0   );
    eNsegMin                    = env.GetValue("fedra.track.NsegMin"        ,      2   );
    float       momentum        = env.GetValue("fedra.track.momentum"       ,      2.  );
    etra.SetMomentum (momentum);
 
    SetPredictionXY(  env.GetValue("fedra.track.PredictionCutXY"   ,  "0 0. 0. 0. 0.") );
    SetPredictionZ(   env.GetValue("fedra.track.PredictionCutZ"    ,  "0 0. 0. 0.") );
    SetPredictionAng( env.GetValue("fedra.track.PredictionCutAng"  ,  "0 0. 0. 0. 0.") );
   
    etra.InitTrZMap(  env.GetValue("fedra.track.TrZmap", "2400 0 120000   2000 0 100000   30" ) );
 
    //adding cell selection
    if (ix >= 0 && iy >= 0){
 
    int ncellsX = env.GetValue("fedra.track.map.NX"      , 19);
    int ncellsY = env.GetValue("fedra.track.map.NY"      , 19);
 
    float xmin = env.GetValue("fedra.track.map.xmin"      , 0.);
    float xmax = env.GetValue("fedra.track.map.xmax"      , 190000.);
    float ymin = env.GetValue("fedra.track.map.ymin"      , 0.);
    float ymax = env.GetValue("fedra.track.map.ymax"      , 190000.);
 
    float overlap_fraction = env.GetValue("fedra.track.map.overlapfraction"      , 0.); //how much should they overlap (for each side)
 
    printf("EdbScanProc::TrackSetBT ** processing cell %d %d\n", ix , iy);
    EdbCell2 * emulsioncell = new EdbCell2();
    Log(2,"EdbScanProc::TrackSetBT","cell layout, %d x cells from %f to %f, %d y cells from %f to %f",ncellsX, xmin, xmax, ncellsY, ymin, ymax );
    emulsioncell->InitCell(ncellsX,xmin,xmax,ncellsY,ymin,ymax,1); //1 is the maximum number for cells. In this case I use the cells only to map positions
    //setting header cut manually
    cut += Form("TMath::Abs(s.eX-%f) < %f && TMath::Abs(s.eY-%f) < %f",
      emulsioncell->X(ix),emulsioncell->Xbin()*(1.+overlap_fraction)/2.,emulsioncell->Y(iy),emulsioncell->Ybin()*(1.+overlap_fraction)/2.);
  }
  
    EdbAffine2D misalign[60];
    if(do_misalign) {
        //           1 2 3 4 5 6  7  8  9
      int dx[9] = {0,0,1,1,1,0,-1,-1,-1};
      int dy[9] = {0,1,1,0,-1,-1,-1,0,1};
      for(int i=0; i<60; i++) {
        misalign[i].ShiftX( dx[i%9] * misalign_offset );
        misalign[i].ShiftY( dy[i%9] * misalign_offset );
        if(gEDBDEBUGLEVEL>1) printf("%d |  %d  %d\n",i, dx[i%9], dy[i%9]);
      }
    }
  
  // read segments and use them for tracking
    int all_volume_segments=0;
    for(int ipass=0; ipass<npass; ipass++) {
      if(gEDBDEBUGLEVEL>1) printf("\n\n*************** ipass=%d ************\n",ipass);
      etra.eCollisionsRate=0;
      EdbAffine2D acorr;
      for(int i=0; i<npl; i++) {
        EdbID *id = ss->GetID(i);
        if (ix >= 0 && iy >= 0){  //we want (for now) to read the same couples for all cells
          id->eMajor = 0;
          id->eMinor = 0;
        }
        EdbPlateP *plate = ss->GetPlate(id->ePlate);
      
        EdbPattern p;
    p.SetScanID(*id);
        //all_volume_segments += eSproc->ReadPatCPnopar(p,*id, cut, do_erase);
        int nread = eSproc->ReadPatCPnopar(p,*id, cut, do_erase);
    all_volume_segments += nread;
        if (nread == 0){
      printf("skipping plate, %i, nread is zero", id->ePlate);
      continue;
    }
        p.SetZ(plate->Z());
        p.SetSegmentsZ();
        p.SetID(i);
        p.SetPID(i);
        p.SetSegmentsPID();
        p.Transform(    plate->GetAffineXY()   );
        p.TransformShr( plate->Shr() );
        p.TransformA(   plate->GetAffineTXTY() );
        p.SetSegmentsPlate(id->ePlate);
      
        if(do_local_corr) {
          int nseg = p.N();
          for(int j=0; j<nseg; j++) {
            EdbSegP *s = p.GetSegment(j);
            plate->CorrectSegLocal(*s);
          }
        }
 
        if(ePRC.doXY ) p.RemovePosMargins( ePRC.x0, ePRC.y0, ePRC.dx,  ePRC.dy  );
    if(ePRC.doAng) p.RemoveAngMargins( ePRC.tx, ePRC.ty, ePRC.dtx, ePRC.dty );
    // TODO doZ
    
    if(do_misalign) {
      p.Transform(&misalign[i]);
      Log(2,"EdbScanTracking::TrackSetBT","apply misalignment of %f",misalign_offset);
    }
    
    if(eDoRealign) 
    {
      if( i>=1  )  etra.CheckPatternAlignment(p,*plate, 0, acorr);
//    if( i>=1  )  etra.CheckPatternAlignment(p,*plate,1);
      //if( i>=5  )  etra.CheckPatternAlignment(p,*plate,2);
      //if( i>=10 )  etra.CheckPatternAlignment(p,*plate,(int)(Sqrt(i)));
    }
    if(do_track)
    {
      Log(1,"EdbScanTracking::TrackSetBT","AddPattern with ScanID: %s and %d segments",id->AsString(),p.N());
      if(i>0) 
        if(etra.eDoUseMCS==3) etra.ExtrapolateTracksToZ_mcs3(p.Z());
        else                  etra.ExtrapolateTracksToZ(p.Z());
        
      etra.FillTrZMap();
      etra.AddPattern(p);
    }
    if(do_shtag) etra.FillXYseg(p);
      }
    }
    
    if(eDoRealign) eSproc->WriteScanSet(idset,*ss);
    
    int ntr = etra.Tracks().GetEntriesFast();
    
    for(int i=0; i<ntr; i++) {
      EdbTrackP *t = (EdbTrackP *)(etra.Tracks().At(i));
      if(t->N()<eNsegMin)  t->SetFlag(-10);
    }
    
    etra.SetSegmentsErrors();
    etra.FitTracks();
 
    int cnt_badtrk=0;
    int cnt_attached_segments=0;
   TObjArray selectedTracks(ntr);
    if(do_comb) {
      etra.CombTracks(selectedTracks);
    } else {
      int cnt=0;
      for(int i=0; i<ntr; i++) {
        EdbTrackP *t = (EdbTrackP *)(etra.Tracks().At(i));
        if(t->Flag()!=-10)  {
          t->SetID(cnt++);
          t->SetCounters();
          t->SetSegmentsTrack();
          t->SetP(momentum);
          selectedTracks.Add(t);
      cnt_attached_segments += t->N();
        } else cnt_badtrk++;
      }
    }
    printf("\n segments all/attached: %d/%d     tracks selected/bad = %d/%d\n",
       all_volume_segments, cnt_attached_segments, selectedTracks.GetEntriesFast(), cnt_badtrk );
    EdbDataProc::MakeTracksTree( selectedTracks, 0., 0., Form("b%s.trk.root", idset.AsString()) );
    TFile f( Form("b%s.trk.root", idset.AsString()) ,"UPDATE");
    env.Write();
    f.Close();
    
    SaveHist(idset,etra);
}

Member Data Documentation

eDoRealign

bool EdbScanTracking::eDoRealign

eNgapMax

int EdbScanTracking::eNgapMax

eNsegMin

int EdbScanTracking::eNsegMin

ePRC

PredictionCut EdbScanTracking::ePRC

eSproc

EdbScanProc* EdbScanTracking::eSproc

---

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

• src/libScan/EdbScanTracking.h
• src/libScan/EdbScanTracking.cxx