void microRootFiles(Int_t run=3280, Int_t maxevent=0, Int_t part=1)
{  
  gROOT->LoadMacro("$VMCWORKDIR/gconfig/rootlogon.C");
  rootlogon();
  //
  // {{{ Set Files			 
  //   Connect source file and the tree
  TFile *reco = new TFile(Form("$RECOOUT/GenTests/run_%d.reco%d.root",run,part));
  TFile *output = new TFile(Form("$RECOOUT/GenTests/OUT/run_%d.reco%d.out.root",run,part),"RECREATE");
  //TFile *reco = new TFile("/nfs/hicran/data/tpc/fopi/2011/mball/run_3280.reco_Jul_31_2012_03.root");
  //TFile *output = new TFile(Form("$RECOOUT/GenTests/OUT/run_%d.reco%d.dEdx.root",run,part),"RECREATE");

  // }}}  

  // {{{ Tree Input
  //
  // TPC Trees
  //  
  TTree *treeTPC = (TTree*)reco->Get("cbmsim"); 
  TClonesArray *combtrks    = new TClonesArray("GFTrack");  
  TClonesArray *cdcGFtrks  = new TClonesArray("GFTrack");
  TClonesArray *tpccdcmat  = new TClonesArray("TMatrixT<double>"); 
  TClonesArray *cdctracks  = new TClonesArray("CdcTrack"); 
  TClonesArray *rpctracks  = new TClonesArray("RpcTrack");
  TClonesArray *barrtracks = new TClonesArray("BarrelTrack");
  TClonesArray *TPCdEdx = new TClonesArray("TpcdEdx");
  TClonesArray *fopievents  = new TClonesArray("FopiEvent");
  treeTPC->GetBranch("TpcCdcPostFit")->SetAutoDelete(kFALSE);
  treeTPC->SetBranchAddress("TpcCdcPostFit",&combtrks); 
  treeTPC->GetBranch("TpcCdcMatArray")->SetAutoDelete(kFALSE);
  treeTPC->SetBranchAddress("TpcCdcMatArray",&tpccdcmat); 
  treeTPC->GetBranch("CdcTrack")->SetAutoDelete(kFALSE);
  treeTPC->SetBranchAddress("CdcTrack",&cdctracks); 
  treeTPC->GetBranch("RpcTrack")->SetAutoDelete(kFALSE);
  treeTPC->SetBranchAddress("RpcTrack",&rpctracks); 
  treeTPC->GetBranch("FopiEvent")->SetAutoDelete(kFALSE);
  treeTPC->SetBranchAddress("FopiEvent",&fopievents);
  treeTPC->GetBranch("CdcTrackPostFit")->SetAutoDelete(kFALSE);
  treeTPC->SetBranchAddress("CdcTrackPostFit",&cdcGFtrks);
  treeTPC->GetBranch("BarrelTrack")->SetAutoDelete(kFALSE);
  treeTPC->SetBranchAddress("BarrelTrack",&barrtracks);
  treeTPC->GetBranch("dEdx")->SetAutoDelete(kFALSE);
  treeTPC->SetBranchAddress("dEdx",&TPCdEdx);

  // deactivate all branches except the needed one
  treeTPC->SetBranchStatus("*",0);
  treeTPC->SetBranchStatus("TpcCdcPostFit.*",1);
  treeTPC->SetBranchStatus("CdcTrack.*",1);
  treeTPC->SetBranchStatus("TpcCdcMatArray.*",1);
  treeTPC->SetBranchStatus("FopiEvent.*",1);
  treeTPC->SetBranchStatus("RpcTrack.*",1);
  treeTPC->SetBranchStatus("CdcTrackPostFit.*",1);
  treeTPC->SetBranchStatus("BarrelTrack.*",1);
  treeTPC->SetBranchStatus("dEdx.*",1);

  // }}} 

  // {{{ Set up Tree and Braches for output
  TTree *dispEvT  = new TTree("dispEvT","Tree for event easy display");
  TTree *dispTrT  = new TTree("dispTrT","Tree for track easy display");
  TTree *dispPtT  = new TTree("dispPtT","Tree for hit easy display");

  Int_t evt, evt_2, numTpcTrC, tpcTrId, trSize, TpcTrSize, GfFlag, CdcFlag, run;
  Float_t evtVx, evtVy, evtVz, MomAft, MomBef, MomGfCdc, Chi_2, cdcMass; 
  Float_t cdcCharge, cdcTheta, cdcPhi, cdcRadius, dEdx, dEdxTpc;
  Float_t GfX, GfY, GfZ, TpcX, TpcY, TpcZ, RpcVel, Z0, D0, bm;
  Float_t hitX, hitY, hitZ, distr;

  dispEvT->Branch("run",&run,"run/I");
  dispEvT->Branch("event",&evt,"event/I");
  dispEvT->Branch("id",&evt_2,"id/I");
  dispEvT->Branch("ntra",&numTpcTrC,"ntra/I");
  dispEvT->Branch("cvx",&evtVx,"cvx/F");
  dispEvT->Branch("cvy",&evtVy,"cvy/F");
  dispEvT->Branch("cvz",&evtVz,"cvz/F");
  //
  dispTrT->Branch("run",&run,"run/I");
  dispTrT->Branch("event",&evt,"event/I");
  dispTrT->Branch("id",&evt_2,"id/I");
  dispTrT->Branch("tid",&tpcTrId,"tid/I");
  dispTrT->Branch("nhit",&trSize,"nhit/I");
  dispTrT->Branch("ntpchit",&TpcTrSize,"ntpchit/I");
  dispTrT->Branch("mom",&MomAft,"mom/F");
  dispTrT->Branch("momb",&MomBef,"momb/F");
  dispTrT->Branch("GfCdcM",&MomGfCdc,"GfCdcM/F");
  dispTrT->Branch("chi",&Chi_2,"chi/F");
  dispTrT->Branch("mass",&cdcMass,"mass/F");
  dispTrT->Branch("charge",&cdcCharge,"charge/F");
  dispTrT->Branch("theta",&cdcTheta,"theta/F");
  dispTrT->Branch("phi",&cdcPhi,"phi/F");
  dispTrT->Branch("radius",&cdcRadius,"radius/F");
  dispTrT->Branch("fitflag",&GfFlag,"fitflag/F");
  dispTrT->Branch("cdcflag",&CdcFlag,"cdcflag/F");
  dispTrT->Branch("vx",&GfX,"vx/F");
  dispTrT->Branch("vy",&GfY,"vy/F");
  dispTrT->Branch("vz",&GfZ,"vz/F");
  dispTrT->Branch("tvx",&TpcX,"tvx/F");
  dispTrT->Branch("tvy",&TpcY,"tvy/F");
  dispTrT->Branch("tvz",&TpcZ,"tvz/F");
  dispTrT->Branch("rpcv",&RpcVel,"rpcv/F");
  dispTrT->Branch("z0",&Z0,"z0/F");
  dispTrT->Branch("dEdx",&dEdx,"dEdx/F");
  dispTrT->Branch("dEdxTpc",&dEdxTpc,"dEdxTpc/F");
  // D0 and Barrel mass 
  dispTrT->Branch("d0",&D0,"d0/F");
  dispTrT->Branch("bmass",&bm,"bmass/F");
  //
  dispPtT->Branch("event",&evt,"event/I");
  dispPtT->Branch("id",&evt_2,"id/I");
  dispPtT->Branch("tid",&tpcTrId,"tid/I");
  dispPtT->Branch("fitflag",&GfFlag,"fitflag/F");
  dispPtT->Branch("x",&hitX,"x/F"); 
  dispPtT->Branch("y",&hitY,"y/F"); 
  dispPtT->Branch("z",&hitZ,"z/F");
  dispPtT->Branch("distr",&distr,"distr/F");
    
  // }}}

  // {{{ Reset Parameters
  //   Start main loop on all events, that are entries of the tree
   
  Int_t nevent = treeTPC->GetEntries(); 
  if(maxevent>0 && maxevent < nevent){nevent=maxevent;} 
  Int_t printsteps = nevent/10;
  Int_t tr_cnt = 0; //it might be useful later on
  Int_t lastfoundtpcevent=0;
  Int_t eventid=0;
  Int_t unmatchedid=0;
  Int_t acspill=1;
  Int_t acevent=1;
  //Int_t Cdctrack=0;
  //Int_t Tpctrack=0;
  Float_t Cosmictrackseen=0;
  Float_t Cosmictrackmatched=0;
  Int_t TTEvent=0; 
  Int_t ev2=0;
  Int_t TpcHitId = 14;
  Int_t CdcHitId = 3;
  double cutLo = 0.0;
  double cutHi = 0.4;

  // }}}

  // {{{ Loop over Events -> CDC 

  for (Int_t ev=0;ev<nevent;ev++){ 
    if(ev%100==0){
      cout<<"Event done: "<<ev<<endl;
    }      
    combtrks->Clear();
    tpccdcmat->Clear();
    cdctracks->Clear();
    rpctracks->Clear();
    cdcGFtrks->Clear();
    barrtracks->Clear();

    treeTPC->GetEvent(ev);    
    Int_t NumTpcTraCand = combtrks->GetEntries(); // Number of TPC candidate tracks
    if(NumTpcTraCand==0) continue;
    ev2 +=1;
    evt = ev;
    evt_2 = ev2;
    // Loop over TPC Track Candidates	 
    std::vector<unsigned int> tpcIDs;
    std::vector<unsigned int> cdcIDs;
    std::vector<unsigned int> cdcgfIDs;
    TMatrixT<double>* tpccdcmatid  = (TMatrixT<double>*) tpccdcmat->At(0);
    FopiEvent* fopiev = (FopiEvent*) fopievents->At(0);
    TVector3 cdcvertex=fopiev->GetVertex();
    run = fopiev->GetRunNum();
    for (Int_t tp=0;tp<NumTpcTraCand;tp++){
      Int_t cdctrackid = (Int_t) (*tpccdcmatid)[tp][1]; 
      Int_t tpctrackid = (Int_t) (*tpccdcmatid)[tp][2];
      /* if(ev<20){
	cout << "ev: " << ev << endl;
	cout << "tpctrackid: " << tpctrackid << " tp: " << tp << endl; } */
      GFTrack* combtrack = (GFTrack*) combtrks->At(tp);
      CdcTrack* cdctrack = (CdcTrack*) cdctracks->At(cdctrackid);
      RpcTrack* rpctrack = (RpcTrack*) rpctracks->At(cdctrackid);
      BarrelTrack* barrtrack = (BarrelTrack*) barrtracks->At(cdctrackid);
      GFTrack* cdcGFtrk = (GFTrack*) cdcGFtrks->At(cdctrackid); 
      //TpcdEdx* dedxtpc = (TpcdEdx*) TPCdEdx->At(tp);
      TpcdEdx* dedxtpc = (TpcdEdx*) TPCdEdx->At(tpctrackid);
      //
      GFAbsTrackRep *rep   = combtrack->getTrackRep(0);
      GFTrackCand cand     = combtrack->getCand();
      GFTrackCand candcdc  = cdcGFtrk->getCand();
      Float_t mombefore    = cdctrack->GetMom();
      Float_t mass         = cdctrack->GetMass();
      Float_t charge       = cdctrack->GetCharge();
      Float_t radius       = cdctrack->GetRadius();
      Float_t theta        = cdctrack->GetTheta();
      Float_t phi          = cdctrack->GetPhi();
      Float_t meanx        = cdctrack->GetMx();
      Float_t meany        = cdctrack->GetMy();
      Float_t z0           = cdctrack->GetZ0();
      Float_t Eloss        = cdctrack->GetEloss();
      Float_t TpcEloss     = dedxtpc->truncMean(cutLo,cutHi);
      // D0 and barrel mass
      Float_t d0           = cdctrack->GetD0();
      Float_t bmass        = barrtrack->GetMass();
      Float_t rpcv         = rpctrack->GetVel();
      TVector3 momentum    = combtrack->getMom();
      TVector3 momentumCdc = cdcGFtrk->getMom();
      Float_t chi2      = rep->getRedChiSqu();
      //Float_t vx = (*tpccdcmatid)[tp][3];
      //Float_t vy = (*tpccdcmatid)[tp][4];  
      //Float_t vz = (*tpccdcmatid)[tp][5]; 
      TVector3 CombVert;
      TVector3 Point1(0.,0.,0.);
      TVector3 Point2(0.,0.,10.);
      TVector3 normVect;
      TVector3 poca_onwire;
      Float_t tvx = (*tpccdcmatid)[tp][6];
      Float_t tvy = (*tpccdcmatid)[tp][7];  
      Float_t tvz = (*tpccdcmatid)[tp][8];
      //
      //rep->extrapolateToLine(Point1,Point2,CombVert,normVect,poca_onwire);
      Int_t StatusFlag = combtrack->getTrackRep(0)->getStatusFlag();
      Int_t CdcStatFlag = cdcGFtrk->getTrackRep(0)->getStatusFlag();
      tpcIDs.clear(); 
      cdcIDs.clear();
      cdcgfIDs.clear();
      tpcIDs   = cand.GetHitIDs(TpcHitId);
      cdcIDs   = cand.GetHitIDs(CdcHitId);
      cdcgfIDs = candcdc.GetHitIDs(); 
      
      tpcTrId    = tp;
      TpcTrSize  = tpcIDs.size();
      trSize     = tpcIDs.size()+cdcIDs.size();
      MomAft     = momentum.Mag();
      MomBef     = mombefore;
      MomGfCdc   = momentumCdc.Mag();
      Chi_2      = chi2;
      cdcMass    = mass;
      cdcCharge  = charge;
      cdcRadius  = radius;
      cdcTheta   = theta;
      cdcPhi     = phi;
      //GfX        = vx; 
      //GfY        = vy;
      //GfZ        = vz;
      GfX        = CombVert.X();
      GfY        = CombVert.Y();
      GfZ        = CombVert.Z();
      TpcX       = tvx;
      TpcY       = tvy;
      TpcZ       = tvz;
      RpcVel     = rpcv;
      Z0         = z0;
      dEdx       = Eloss;
      dEdxTpc    = TpcEloss;
      // barrel mass and D0
      bm         = bmass;
      D0         = d0;
      GfFlag     = StatusFlag; 
      CdcFlag    = CdcStatFlag;

      if(ev<20){
      std::cout << "TPC hits in track: " << tpcIDs.size() << std::endl; 
      std::cout << "CDC hits in track: " << cdcIDs.size() << std::endl; 
      std::cout << "CDC hits in GF track: " << cdcgfIDs.size() << std::endl;
      }
      //std::cout << "TPC hits in track: " << tpcIDs.size() << "CDC hits in track: "
      //	<< cdcIDs.size(); << "CDC hits in GF: " << cdcgfIDs.size() << std::endl;

      /*    if(!StatusFlag==0){
	std::cout << " event: " << 
	  evt << " matched evt: " << evt_2 << " Track " << 
	  tpcTrId << " # of tracks " << NumTpcTraCand <<  std::endl;
	  } */

      dispTrT->Fill();

      //  THIS TAKES MUCH MEMORY, DO NOT RUN TOO MANY EVENTS WITH IT
      
      for (Int_t nhit=0;nhit<tpcIDs.size()+cdcIDs.size();nhit++){
	GFAbsRecoHit *thehit = combtrack->getHit(nhit);
	if(dynamic_cast<TpcSPHit*>(thehit) !=NULL){
	TMatrixD thehitpoint = thehit->getRawHitCoord();
	Double_t disttocirc=pow(pow((thehitpoint[0][0]-meanx),2)+pow((thehitpoint[1][0]-meany),2),0.5)-radius; 
	hitX  = thehitpoint[0][0];
	hitY  = thehitpoint[1][0];
	hitZ  = thehitpoint[2][0];
	distr = disttocirc; 
	dispPtT->Fill();
	}
      }
      
      //
    } 
    
    numTpcTrC = NumTpcTraCand;
    evtVx = cdcvertex.X();
    evtVy = cdcvertex.Y();
    evtVz = cdcvertex.Z();
    dispEvT->Fill();

  }
  
  dispEvT->Write();
  dispTrT->Write();
  dispPtT->Write();
  
  reco->Close();
  output->Close();    
}