/////////////////////////////////////////////////////////////////////
///Analyzing Charged Tracks                                      ////
/// Sample Macro to be used at RCF                               ////  
///To extract some information from nDst's and create some trees ////
///that will later be used for physics studies                   ////
/// 3 trees with the option of EMCAL SuperModule  check          ////
///                                                              ////
/// Track-MB all triggered                                       ////
/// Track1-4x4c subset of MB                                     ////
/// Track2-plus a spin info tree, if not needed comment out      ////  
///                                                              ////
///INIT:           Initialization at startup                     ////
///                Create histograms and trees here.             ////
///INITRUN:        Initialization which need the run number.     ////
///PROCESS_EVENT:  Analysis code goes here.                      ////
///RESET:          Called when a new run opened.                 ////
///RESETEVENT:     Called at the end of each event.              ////
///END:            Called at end run.                            ////
///--------------Astrid Morreale March 15 2007-------------------////
///--------------Phenix Ext:7266---------------------------------////
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
 
//============================General modules
#include <cmath>
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <cmath>
//=============================Classes
#include "TH1F.h"
#include "TH2F.h"
#include "TTree.h"
#include "TFile.h"
#include "TNtuple.h"
//==============================Libraries

#include "PHNodeIterator.h"
#include "PHTypedNodeIterator.h"
#include "PHCompositeNode.h"
#include "PHDataNode.h"
#include "ChargedTracks.h"
#include "phool.h"


 using namespace std;
 using namespace findNode;
 static TFile* tmpf;
  
//==============================Constructor  ====

ChargedTracks::ChargedTracks(const char *outfile,  short which_trigger):SubsysReco("charged pions")
  {

    chosen_trigger = which_trigger;

    if(chosen_trigger == 1)
    printf ("ERT4x4LL1 trigger selected.\n");

    if (chosen_trigger == 0)
    printf ("MinBias trigger selected. \n");
    event = 0;
    sprintf(outfilename,"%s",outfile);
 
    // MEB_THRESHOLD = -1; // No Threshold Applied..
   	return ;
	
  }//ChargedTracks

//=============================This is just to register histograms/Tress
   
  int ChargedTracks::Init(PHCompositeNode *topNode)
  {
 
   tmpf = new TFile(outfilename,"recreate");
   nTrig   = 0; //MB   
   n4x4c   = 0; //e4c only
  

   for(cross = 0; cross < 120; cross++){ 
   E4cTriggerPerCross[cross] = 0; 
   MBTriggerPerCross[cross]  = 0;
   }//FOR LOOP
  
   Tout   = new TTree("Tout",     "Tout");
   Track  = new TTree("Track",    "Track");//MB
   Track1 = new TTree("Track1",   "Track1");//4x4c
   Track2 = new TTree("Track2",   "Track2");//spindata
  
   //-------------MB 
   Track->Branch("evt",           &evtnumber,           "evt/I"); 
   Track->Branch("krun",          &runnumber,          "krun/I");
   Track->Branch("seg",           &segnumber,           "seg/I");
   Track->Branch("charge",        &charge,              "charge/I");
   Track->Branch("cross",         &cross,               "cross/I");
   Track->Branch("fill_number",   &fill_number,         "fill_number/I");   
   Track->Branch("mom",           &mom,                 "mom/F");
   Track->Branch("the0",          &the0,                "the0/F");
   Track->Branch("pt",            &pt,                  "pt/F");  
   Track->Branch("prob",          &prob,                "prob/F");
   Track->Branch("e",             &e,                   "e/F");
   Track->Branch("n0",            &n0,                  "n0/S"); 
   Track->Branch("n1",            &n1,                  "n1/S");
   Track->Branch("pc3sdphi",      &pc3sdphi,            "pc3sdphi/F");
   Track->Branch("pc3sdz",        &pc3sdz,              "pc3sdz/F");
   Track->Branch("emcsdphi",      &emcsdphi,            "emcsdphi/F");
   Track->Branch("emcsdz",        &emcsdz,              "emcsdz/F");                              
   Track->Branch("tecsdphi",      &tecsdphi,            "tecsdphi/F");  
   Track->Branch("tecsdalpha",    &tecsdalpha,          "tecsdalpha/F");
   Track->Branch("zed",           &zed,                 "zed/F");
   Track->Branch("swarnmap",      &swarnmap,            "swarnmap/I");
   Track->Branch("deadmap",       &deadmap,             "deadmap/I");
   
   //--------------4x4c------------------------------------------
   Track1->Branch("cswarnmap",      &swarnmap,            "cswarnmap/I");
   Track1->Branch("cdeadmap",       &deadmap,             "cdeadmap/I");        
   Track1->Branch("cevt",           &evtnumber,           "cevt/I"); 
   Track1->Branch("ckrun",          &runnumber,          "ckrun/I");
   Track1->Branch("cseg",           &segnumber,           "cseg/I");
   Track1->Branch("ccharge",        &charge,              "ccharge/I");
   Track1->Branch("ccross",         &cross,               "ccross/I");
   Track1->Branch("cfill_number",   &fill_number,         "cfill_number/I");   
   Track1->Branch("cmom",           &mom,                 "cmom/F");
   Track1->Branch("cthe0",          &the0,                "cthe0/F");
   Track1->Branch("cpt",            &pt,                  "cpt/F");  
   Track1->Branch("cprob",          &prob,                "cprob/F");
   Track1->Branch("ce",             &e,                   "ce/F");
   Track1->Branch("cn0",            &n0,                  "cn0/S"); 
   Track1->Branch("cn1",            &n1,                  "cn1/S");
   Track1->Branch("cpc3sdphi",      &pc3sdphi,            "cpc3sdphi/F");
   Track1->Branch("cpc3sdz",        &pc3sdz,              "cpc3sdz/F");
   Track1->Branch("cemcsdphi",      &emcsdphi,            "cemcsdphi/F");
   Track1->Branch("cemcsdz",        &emcsdz,              "cemcsdz/F");                              
   Track1->Branch("ctecsdphi",      &tecsdphi,            "ctecsdphi/F");  
   Track1->Branch("ctecsdalpha",    &tecsdalpha,          "ctecsdalpha/F");
   Track1->Branch("czed",           &zed,                 "czed/F");
   Track1->Branch("cswarnmap",      &swarnmap,            "cswarnmap/I");
   Track1->Branch("cdeadmap",       &deadmap,             "cdeadmap/I");

   //----------------Spin info--------------------------------------------

   
   Track2->Branch("runnumber",     &runnumber,           "runnumber/I");
   Track2->Branch("spinCombo",     &spinCombo,           "spinCombo/I"); 
   Track2->Branch("fill_number",   &fill_number,         "fill_number/I");  
   Track2->Branch("scaler",        &scaler,              "scaler/I");
   Track2->Branch("blueSpin",      &blueSpin,            "blueSpin/I");
   Track2->Branch("yellowSpin",    &yellowSpin,          "yellowSpin/I");
   Track2->Branch("crossing",      &crossing,            "crossing/I");
   
   
//======================Histograms===========================================
   
//-------------------MB-------------------------------------------------------
   MBYieldsPerCrossPos           = new TH1F("MBYieldsPerCrossPos",         "",120,0,120);
   MBYieldsPerCrossPos1To4Gev    = new TH1F("MBYieldsPerCrossPos1To4Gev",  "",120,0,120);
   MBYieldsPerCrossPos5To6Gev    = new TH1F("MBYieldsPerCrossPos5To6Gev",  "",120,0,120);
   MBYieldsPerCrossPos6To7Gev    = new TH1F("MBYieldsPerCrossPos6To7Gev",  "",120,0,120);
   MBYieldsPerCrossPos7To8Gev    = new TH1F("MBYieldsPerCrossPos7To8Gev",  "",120,0,120);
   MBYieldsPerCrossPos8To10Gev   = new TH1F("MBYieldsPerCrossPos8To10Gev", "",120,0,120);
        MBYieldsPerCrossPos10To15Gev  = new TH1F("MBYieldsPerCrossPos10To15Gev","",120,0,120);
        MBYieldsPerCrossNeg           = new TH1F("MBYieldsPerCrossNeg",         "",120,0,120);
        MBYieldsPerCrossNeg1To4Gev    = new TH1F("MBYieldsPerCrossNeg1To4Gev",  "",120,0,120);
        MBYieldsPerCrossNeg5To6Gev    = new TH1F("MBYieldsPerCrossNeg5To6Gev",  "",120,0,120);
        MBYieldsPerCrossNeg6To7Gev    = new TH1F("MBYieldsPerCrossNeg6To7Gev",  "",120,0,120);
        MBYieldsPerCrossNeg7To8Gev    = new TH1F("MBYieldsPerCrossNeg7To8Gev",  "",120,0,120);
        MBYieldsPerCrossNeg8To10Gev   = new TH1F("MBYieldsPerCrossNeg8To10Gev", "",120,0,120);
        MBYieldsPerCrossNeg10To15Gev  = new TH1F("MBYieldsPerCrossNeg10To15Gev","",120,0,120);

  //---------------4x4c------------------------------------------------------
        E4cYieldsPerCrossPos          = new TH1F("E4cYieldsPerCrossPos",         "",120,0,120);
        E4cYieldsPerCrossPos1To4Gev   = new TH1F("E4cYieldsPerCrossPos1To4Gev",  "",120,0,120);
        E4cYieldsPerCrossPos5To6Gev   = new TH1F("E4cYieldsPerCrossPos5To6Gev",  "",120,0,120);
        E4cYieldsPerCrossPos6To7Gev   = new TH1F("E4cYieldsPerCrossPos6To7Gev",  "",120,0,120);
        E4cYieldsPerCrossPos7To8Gev   = new TH1F("E4cYieldsPerCrossPos7To8Gev",  "",120,0,120);
        E4cYieldsPerCrossPos8To10Gev  = new TH1F("E4cYieldsPerCrossPos8To10Gev", "",120,0,120);
        E4cYieldsPerCrossPos10To15Gev = new TH1F("E4cYieldsPerCrossPos10To15GeV","",120,0,120);
        E4cYieldsPerCrossNeg          = new TH1F("E4cYieldsPerCrossNeg",         "",120,0,120);
        E4cYieldsPerCrossNeg1To4Gev   = new TH1F("E4cYieldsPerCrossNeg1To4Gev",  "",120,0,120);
        E4cYieldsPerCrossNeg5To6Gev   = new TH1F("E4cYieldsPerCrossNeg5To6Gev",  "",120,0,120);
        E4cYieldsPerCrossNeg6To7Gev   = new TH1F("E4cYieldsPerCrossNeg6To7Gev",  "",120,0,120);
        E4cYieldsPerCrossNeg7To8Gev   = new TH1F("E4cYieldsPerCrossNeg7To8Gev",  "",120,0,120);
        E4cYieldsPerCrossNeg8To10Gev  = new TH1F("E4cYieldsPerCrossNeg8To10Gev", "",120,0,120);
        E4cYieldsPerCrossNeg10To15Gev = new TH1F("E4cYieldsPerCrossNeg10To15Gev","",120,0,120);
 
  
  return EVENT_OK;

  }//matches Init 
 
//------------------------------INIT -----------------------------------------------------------
  
 int ChargedTracks::InitRun(PHCompositeNode *topNode)
{
   recoConsts *rc = recoConsts::instance();
   if(verbosity>0) {cout << "Calling InitRun for Run" << rc->get_IntFlag("RUNNUMBER") << endl;}
   getSpins(rc->get_IntFlag("RUNNUMBER"));
   

   return EVENT_OK;
   
}//INIT RUN

//=====================PROCESS TRACK=============================================================

int ChargedTracks::process_event(PHCompositeNode *topNode)
{
 
  if(findNodes(topNode) == ABORTRUN) return ABORTRUN;
 
  static int ncalls = 0;
    ncalls++;
 
  if(ncalls % 10000 == 0 && verbosity)

 //{cout << "Ncalls = " << ncalls << " (" << event << ")" << endl;}
  
  if(fabs(d_gbl->getBbcZVertex())>30) return EVENT_OK; //global cut, perform this before anything else
     
   d_evt   = getClass<EventHeader>      (topNode, "EventHeader");
   d_cnt   = getClass<PHCentralTrack>   (topNode, "PHCentralTrack");
   d_gbl   = getClass<PHGlobal>         (topNode, "PHGlobal");
   d_sdo   = getClass<SpinDataEventOut> (topNode, "SpinDataEventOut");
   d_ert   = getClass<ErtOut>           (topNode, "ErtOut");
   d_trig  = getClass<TrigLvl1>         (topNode, "TrigLvl1");

  if (!d_evt || !d_cnt || !d_gbl || !d_sdo || !d_ert || !d_trig) {
  cout << PHWHERE << "Expected nodes are not in the tree." << endl;
    return 0;
      }

  if (event != d_evt-> get_EvtSequence())
      event  = d_evt-> get_EvtSequence();
    
  //more info on the trigger can be found at:
  //http://www.phenix.bnl.gov/WWW/trigger/pp/c-arm/Run3/emc/EmCal_Trigger_ckts_1998_NSS_paper.pdf
  TriggerHelper d_trg(topNode);

  isMB   = d_trg.IsEventMinBias();                           //min bias +ert
  isE4c  = d_trg.didLevel1TriggerFire("ERTLL1_4x4c&BBCLL1"); //only ert

    
  //--------all triggered, MB{including 4x4c}  
 if (chosen_trigger == 0 && isMB) {
             
            nTrig++;
            MBTriggerPerCross[cross]++;  

   //----------------do not count triggers twice----------------
  
  if (chosen_trigger == 0 && !isMB) return 0;                                              
  if (chosen_trigger == 1 && (!isE4c || isMB) )return 0;
 
  lvl1_trigraw     = d_trig->get_lvl1_trigraw();
  lvl1_triglive    = d_trig->get_lvl1_triglive();
  lvl1_trigscaled  = d_trig->get_lvl1_trigscaled();
  lvl1_clock_cross = d_trig->get_lvl1_clock_cross();
  cross            = (int) d_sdo ->GetSpinGL1CrossingID();
  }//MB trigger
  
  //--------------triggered 4x4c----------------------------
  if (chosen_trigger == 1 && isE4c) {

            n4x4c++;  
            E4cTriggerPerCross[cross]++ ;
  if (chosen_trigger == 1 && (!isE4c || isMB) )return 0;
            


  clvl1_trigraw     = d_trig->get_lvl1_trigraw();
  clvl1_triglive    = d_trig->get_lvl1_triglive();
  clvl1_trigscaled  = d_trig->get_lvl1_trigscaled();
  clvl1_clock_cross = d_trig->get_lvl1_clock_cross();
  ccross            = (int) d_sdo ->GetSpinGL1CrossingID();
   ncERT = d_ert -> get_ERThit_N();
  
  if (ncERT > 200) {
      printf ("Number of ERT hits out of bounds. (More than 199 hits.)");  //not likely, but eh.
    return 0;
    }
  //====================More on the ERTOut object==============================================//
  //https://www.phenix.bnl.gov/WWW/p/draft/xiewei/EMCal-RICH-Trigger/simulation/ErtOut.html    //
  // int ERThit_N;   Number of ERT hits in a event.                                            //
  //int ERTtrigmode[ERThit_N]; Trigger mode 0:4x4a, 1:4x4b, 2:4x4c, 3:2x2, 4:RICH              //
  //int ERTarm[ERThit_N]; arm 0:west, 1:east                                                   //
  //int ERTsector[ERThit_N]; sector 0,1,2,3                                                    //
  //int ERTsm[ERThit_N]; super module(SM) id                                                   //
  // SM counts from left to right, from bottom to top with looking from outside of the detector//
  //			0-17 for PbSc                                                          //
  //			0-31 for PbGl                                                          //
  //			0-31 for RICH                                                          //
  //===========================================================================================//    

      for (int i = 0; i < ncERT; i++) {
       cE4bit[i] = 0;//reset usually is 0 or 1
       cERTarm   = d_ert -> get_ERTarm (i);
       cERTsect  = d_ert -> get_ERTsector (i);
       cERTsm    = d_ert -> get_ERTsm (i);
       cE4bit[i] = d_ert -> get_ERTbit (2, ERTarm, ERTsect, ERTsm);//2=
                 
                }//int i
              }//if is E4c
  

     number_of_charged_tracks = d_cnt -> get_npart();
     for (t = 0; t < number_of_charged_tracks; t++) {// unsigned int
    
     trackArm          = (int) (d_cnt -> get_dcarm(t)+1)%2;//DC &track arm are flipped
     trackSect         = (int) d_cnt -> get_sect(t);


 
      //this below is only to check that the shower was caused by the particle going into the supermodule.//
      //you can uncomment-out  if you need to perform this check
      //track bit is not needed                                                                           //
      //if (isE4c) {//if level1 trigger fired perform this granularity check                               //
      //trackYSect         = (int) d_cnt -> get_ysect(t);                                                 //
      //trackZSect         = (int) d_cnt -> get_zsect(t);                                                 //
      //trackSM            = (trackYSect/12)*6 + (trackZSect/12); // PbSc                                 //
      //if (trackArm == 1 && trackSect < 2)//DC arm ==0, EMC Arm ==1                                      //
      //trackSM           = (trackYSect/12)*8 + (trackZSect/12); // PbGl                                  //
      //trackBit          = d_ert -> get_ERTbit(2, trackArm, trackSect, trackSM);                         //
      // }//if(isE4c)                                                                                      //
      ////////////////////////////////////////////////////////////////////////////////////////////////////// 
        
     number_of_charged_tracks    = d_cnt->get_npart();
     quality                     = d_cnt->get_quality(t);
     mom                         = d_cnt->get_mom(t);
     the0                        = d_cnt->get_the0(t);
     pt                          = mom*sin(the0);
     charge                      = d_cnt->get_charge(t);
     prob                        = d_cnt->get_prob(t);
     pc3sdz                      = d_cnt->get_pc3sdz(t);
     pc3sdphi                    = d_cnt->get_pc3sdphi(t);
     emcsdz                      = d_cnt->get_emcsdz(t);
     emcsdphi                    = d_cnt->get_emcsdphi(t);
     tecsdphi                    = d_cnt->get_tecsdphi(t);
     tecsdalpha                  = d_cnt->get_tecsdalpha(t);
     n0                          = d_cnt->get_n0(t);
     n1                          = d_cnt->get_n1(t);
     e                           = d_cnt->get_emce(t);
     zed                         = d_cnt->get_zed(t);
     swarnmap                    = d_cnt->get_swarnmap(t); 
     deadmap                     = d_cnt->get_deadmap(t);  
     evtnumber                   = Sync->EventNumber();      
     segnumber                   = Sync->SegmentNumber();
     bbcVtx                      = d_gbl-> getBbcZVertex();
     runnumber                   = Runheader->get_RunNumber();
    
     //---useless spin variables, they are never accurate from the ndst's but here they are in case you want to convince yourself--
     //yello                       = d_sdo->GetSpinDirectionYellowFromV124();
     //blue                        = d_sdo->GetSpinDirectionBlueFromV124();
     
    //------------------------------Trigger selection---------------------------------
     if ((quality==63||quality==31)&& fabs(zed)<70){//insert your cuts here, in this example we only use 2 cuts

	if(isMB){   
	  
        //////////again uncomment if you need to use the SM check/////////////////////////////////////////////////       
        //if(isE4c){ 
        //if(isE4c && trackBit ==1){    //Extra granularity for Lv1trigger 0=no-4x4c bit check, 1=4x4c bit check///
        //cout<<"getting track bit"<<endl;                                                                     ///
	//////////////////////////////////////////////////////////////////////////////////////////////////////////

              Track->Fill(); 
	      if(charge == 1){
		if (5< pt  && pt <15){ MBYieldsPerCrossPos->Fill(cross);}
		if (1< pt  && pt <4) { MBYieldsPerCrossPos1To4Gev->Fill(cross);}
		if (5< pt  && pt <6) { MBYieldsPerCrossPos5To6Gev->Fill(cross);}
		if (6< pt  && pt <7) { MBYieldsPerCrossPos6To7Gev->Fill(cross);}
		if (7< pt  && pt <8) { MBYieldsPerCrossPos7To8Gev->Fill(cross);}
		if (8< pt  && pt <10){ MBYieldsPerCrossPos8To10Gev->Fill(cross);}
		if (10<pt  && pt <15){ MBYieldsPerCrossPos10To15Gev->Fill(cross);}
 	                      }
	      if(charge == -1){
		if (5< pt  && pt <15){ MBYieldsPerCrossNeg->Fill(cross);}
		if (1< pt  && pt <4) { MBYieldsPerCrossNeg1To4Gev->Fill(cross);}
		if (5< pt  && pt <6) { MBYieldsPerCrossNeg5To6Gev->Fill(cross);}
		if (6< pt  && pt <7) { MBYieldsPerCrossNeg6To7Gev->Fill(cross);}
		if (7< pt  && pt <8) { MBYieldsPerCrossNeg7To8Gev->Fill(cross);}
		if (8< pt  && pt <10){ MBYieldsPerCrossNeg8To10Gev->Fill(cross);}
                if (10<pt  && pt <15){ MBYieldsPerCrossNeg10To15Gev->Fill(cross);}     
	                      }

                          }//isMB
	    
	if (isE4c){

	  Track1->Fill();
        
            if(charge == 1){
		if (5< pt  && pt <15){ E4cYieldsPerCrossPos->Fill(cross);}
		if (1< pt  && pt <4) { E4cYieldsPerCrossPos1To4Gev->Fill(cross);}
		if (5< pt  && pt <6) { E4cYieldsPerCrossPos5To6Gev->Fill(cross);}
		if (6< pt  && pt <7) { E4cYieldsPerCrossPos6To7Gev->Fill(cross);}
		if (7< pt  && pt <8) { E4cYieldsPerCrossPos7To8Gev->Fill(cross);}
		if (8< pt  && pt <10){ E4cYieldsPerCrossPos8To10Gev->Fill(cross);}
		if (10<pt  && pt <15){ E4cYieldsPerCrossPos10To15Gev->Fill(cross);}
 	                      }
	      if(charge == -1){
		if (5< pt  && pt <15){ E4cYieldsPerCrossNeg->Fill(cross);}
		if (1< pt  && pt <4) { E4cYieldsPerCrossNeg1To4Gev->Fill(cross);}
		if (5< pt  && pt <6) { E4cYieldsPerCrossNeg5To6Gev->Fill(cross);}
		if (6< pt  && pt <7) { E4cYieldsPerCrossNeg6To7Gev->Fill(cross);}
		if (7< pt  && pt <8) { E4cYieldsPerCrossNeg7To8Gev->Fill(cross);}
		if (8< pt  && pt <10){ E4cYieldsPerCrossNeg8To10Gev->Fill(cross);}
                if (10<pt  && pt <15){ E4cYieldsPerCrossNeg10To15Gev->Fill(cross);}     
	                   
                             }	

     
                }//isE4c



	
           /////////////////////////////////////////////////////////////////////////
	   // }//isE4+TrackBit bit
	   //
           ////////////////////////////////////////////////////////////////////////    

     }//all cuts, quality etc.
     }//t loop

     return EVENT_OK;
    }//process event
  
//---------------------------------------------------------------------

  void ChargedTracks::getSpins( int run) {//need to close
    // Open  rel-lumi ascii file in this case, Kieran's
    // Will read in spin directions for each crossing number.
    // Will  also record Fill number
    // int minRun =168705;
    // int maxRun =179846;
    // int oldRun[200000][120];
    // for(int l =minRun; l<maxRun; l++){
    //
    //        for (int j=0; j<120; j++){
    //                    oldRun[l][j]=0;
    //
    // }
    // }
    // for (int i = 0; i < 120; i++) {
    //spinCombo[i] = 0;//just a  reset      
    //}
    
      ifstream rellumifin;
      //run5pp lumi files at ccj  Make SURE TO USE THE CORRECT PRODUCTION LIBRARIES!! 
    //char* fileprefix = "/ccj/u/boyle/work/MakeTextFile/RelLumiFilesWithSpinQA/gl1p";

      //run5pp lumi files at rcf!!!!Make SURE TO USE THE CORRECT PRODUCTION LIBRARIES!!!
      char* fileprefix = "/phenix/data12/kboyle/RUN5/RelLumiQAFilesWithSpinPro72-73/gl1p";
      char* filesuffix = ".dat";
      char buffer[1024];
      char crun[8];
     
      sprintf(crun,"%d",run);
      strcpy(buffer,"");
      strcat(buffer, fileprefix);
      strcat(buffer, crun);
      char* rellumifilename = strcat(buffer, filesuffix);
      rellumifin.open(rellumifilename);
      if (!rellumifin.is_open()) cout << "Could not open relative luminosity file " << rellumifilename << endl;
      else cout << "Opened relative luminosity file " << rellumifilename << endl;

      //---------Get the fill number------------------------------
           for (crossing = 0 ; crossing < 2; crossing++) {
	
	   if(crossing == 0 ){
	      
	     char temp9[16];
	    
	    rellumifin>>temp9>>runnumber;}
	
	    if(crossing == 1){//else
	    
	    char temp3[16];
	    rellumifin>> temp3 >>fill_number;
	 
	    }
	 
	 }//i =1 to 2
 
	  for (crossing =0 ;crossing < 120; crossing ++){//for(int crossB = 0; crossB< 120; crossB++){
	 	     
	   char temp1[32];
	   int temp2;
        // if(oldRun[runnumber][crossing]==1)continue;
	rellumifin >> temp1 >> scaler >> temp2 >> temp2 >> temp2 >> blueSpin >> yellowSpin;//we are after IP12, thus the spins should be flipped.

	if      (blueSpin == -1 &&  yellowSpin == -1) spinCombo = 0;//floor only applies to float
	else if (blueSpin == -1 &&  yellowSpin == 1)  spinCombo = 1;
	else if (blueSpin ==  1 &&  yellowSpin == -1) spinCombo = 2;
	else if (blueSpin ==  1 &&  yellowSpin ==  1) spinCombo = 3;
	else spinCombo = 4;


        Track2->Fill();      

	}//120 loop
        

      rellumifin.close(); //where is good place to close the file=After you get the info, here it should be okay. 
 } //get spins
  
	


//=======================================END FUNCTION, here we make a handy dandy txt file (sprinf)=============
int ChargedTracks::End(PHCompositeNode *topNode){

  //here you can create text files if you wished to do so
  //Otherwise just close the tmpf created earlier to register the histos/trees
   cout<<"dumpingHist"<<endl;
                                                                                                                                                       
   cout<<"finished"<<endl;
  
  tmpf->Write();
  tmpf->Close();
  return EVENT_OK;
                                                                                                                                                
                                                                                                                                                     
}//End(PHcompositeNode)

//=================================Another double Check============================
//=================================Find Nodes ======================================
int ChargedTracks::findNodes(PHCompositeNode *topNode){
  int iret = EVENT_OK;
                                                                                                                                                             
  PHTypedNodeIterator<PHGlobal> globaliter(topNode);
  PHIODataNode <PHGlobal> *PHGlobalNode = globaliter.find("PHGlobal");
  if (PHGlobalNode){
    d_gbl = PHGlobalNode->getData();
  }
  else{
    cout << PHWHERE << "global  Node missing, aborting" << endl;
    return ABORTRUN;
  }
                                                                                                                                                             
  PHTypedNodeIterator<SyncObject> synciter(topNode);
  PHIODataNode<SyncObject> *SyncNanoNode = synciter.find("Sync");
  if (SyncNanoNode) {
    Sync = SyncNanoNode->getData();
  }
  else{
    cout << PHWHERE << "Sync Node missing, aborting" << endl;
    return ABORTRUN;
  }
                                                                                                                                                             
  PHTypedNodeIterator<PHCentralTrack> centraltrackiter(topNode);
  PHIODataNode<PHCentralTrack> *PHCentralTrackNode = centraltrackiter.find("PHCentralTrack");
  if (PHCentralTrackNode){
    d_cnt = PHCentralTrackNode->getData();
  }
  else{
    cout << PHWHERE << "PHCentralTrack Node missing, aborting" << endl;
    return ABORTRUN;
  }
                                                                                                                                                             
  PHTypedNodeIterator<SpinDataEventOut>    spindataEventoutiter(topNode);
  PHIODataNode<SpinDataEventOut> *SpinDataEventOutNode = spindataEventoutiter.find("SpinDataEventOut");
  if (SpinDataEventOutNode) {
    d_sdo = SpinDataEventOutNode->getData();
  }
  else{
    cout << PHWHERE << "SpinDataEventOut Node missing, aborting" << endl;
    return ABORTRUN;
  }

  PHTypedNodeIterator<RunHeader>    runheadernanoiter(topNode);
  PHIODataNode<RunHeader> *RunHeaderNanoNode = runheadernanoiter.find("RunHeader");
  if (RunHeaderNanoNode) {
    Runheader = RunHeaderNanoNode->getData();
  }
  else{
    cout << PHWHERE << "RunHeader Node missing, aborting" << endl;
    return ABORTRUN;
  }

  return iret;
}//find nodes function

//-------------------------------------------------------------------------------------
int ChargedTracks::Reset(PHCompositeNode *topNode){
  cout<<"CALLED RESET!!!!!!!!!"<<endl;
  return EVENT_OK;
}
                                                                                                                                                        
//-------------------------------------------------------------------------------------
int ChargedTracks::ResetEvent(PHCompositeNode *topNode){
  return EVENT_OK;
}