Coming back to splitting. Adding copy constructor to AliMUONTrack (Christian Finck)

[u/mrichter/AliRoot.git] / TOF / AliTOFSDigits2Digits.C

Int_t AliTOFSDigits2Digits(Int_t nev = 1) {

  // Adapted to the NewIO by I.Belikov (Jouri.Belikov@cern.ch)
  // number 3 is a legacy from AliDigit object
    
  Int_t rc = 0;

  if (gAlice)
    {
      delete gAlice->GetRunLoader();
      delete gAlice;
      gAlice = 0x0;
    }
  
  AliRunLoader* rl = AliRunLoader::Open("galice.root");
  if (rl == 0x0)
    {
      cerr<<"Can not open session"<<endl;
      rc = 1;   
      return rc;
    }
  
  if (rl->LoadgAlice())
    {
      cerr<<"Error occured while loading gAlice"<<endl;
      rc = 2;
      return rc;
    }
  
  AliLoader *tofl = rl->GetLoader("TOFLoader");
   if (tofl == 0x0)
     {
       cerr<<"Can not get the TOF Loader"<<endl;
       rc = 3;
       return rc;
     }
   
   gAlice=rl->GetAliRun();
   if (!gAlice)
     {
       cerr<<"Can't get gAlice !\n";
       rc = 4;
       return rc;
     }
   
   tofl->LoadSDigits("read");
   tofl->LoadDigits("recreate");
   
   Int_t totndig=0;   // total number of digits
   Int_t tottracks=0; // total number of tracks contributing to totndig
   
   if (nev>rl->GetNumberOfEvents()) nev=rl->GetNumberOfEvents();
   
   TClonesArray *fSDigits=new TClonesArray("AliTOFSDigit",  1000); 
   TClonesArray *fDigits =new TClonesArray("AliTOFdigit",  1000);
   TClonesArray &da=*fDigits; 

   for (Int_t ievent = 0; ievent < nev; ievent++) {
     rl->GetEvent(ievent);
     
     TTree *sTree=tofl->TreeS();
     if (sTree == 0)
       {
	 cerr<<"Can't get the sdigit tree !\n";
	 rc = 5;
	 return rc;
       }
     TBranch *branch=sTree->GetBranch("TOF");
     if (!branch)
       {
	 cerr<<"Cant' get the branch !\n";
	 rc = 6;
	 return rc;
       }
     branch->SetAddress(&fSDigits);           
    
    TTree *dTree=tofl->TreeD();
    if (dTree == 0) {
       tofl->MakeTree("D");
       dTree=tofl->TreeD();
    }
    branch=dTree->GetBranch("TOF");
    if (!branch) dTree->Branch("TOF",&fDigits);    
    else branch->SetAddress(&fDigits);

    Int_t nEntries = sTree->GetEntries();                                
    for (Int_t iEntry = 0; iEntry < nEntries; iEntry++) {
      sTree->GetEvent(iEntry);
      
      Int_t ndig = fSDigits->GetEntriesFast();
      cout << "----------------<AliTOFSDigits2Digits>----------------" << endl;
      cout << "Found " << ndig << " TOF SDigits for event " << ievent << endl;
      cout << "------------------------------------------------------" << endl;

      for (Int_t k = 0; k < ndig; k++) {
	Int_t    vol[5];       // location for a digit
	
	// Get the information for this digit
	AliTOFSDigit *tofsdigit = (AliTOFSDigit *)fSDigits->UncheckedAt(k);

	Int_t nslot=tofsdigit->GetNDigits(); // get the number of slots
	                                     // for current sdigit

	// TOF sdigit volumes (always the same for all slots)
	Int_t sector    = tofsdigit->GetSector(); // range [0-17]
	Int_t plate     = tofsdigit->GetPlate();  // range [0- 4]
	Int_t strip     = tofsdigit->GetStrip();  // range [0-19]
	Int_t padz      = tofsdigit->GetPadz();   // range [0- 1]
	Int_t padx      = tofsdigit->GetPadx();   // range [0-47]

	vol[0] = sector;
	vol[1] = plate;
	vol[2] = strip;
	vol[3] = padx;
	vol[4] = padz;

	//--------------------- QA section ----------------------
	// in the while, I perform QA
	Bool_t isSDigitBad = (sector<0 || sector>17 || 
                               plate<0 || plate >4  || 
                                padz<0 || padz>1    || 
                                padx<0 || padx>47);
	
	if (isSDigitBad)
	  {
	    cout << "<AliTOFSDigits2Digits>  strange sdigit found" << endl;
	    rc = 7;
	    return rc;
	  }
	//-------------------------------------------------------

	// start loop on number of slots for current sdigit
	for (Int_t islot = 0; islot < nslot; islot++) {
	  Float_t  digit[2];     // TOF digit variables
          const Int_t kMAXDIGITS = 3;
	  Int_t tracknum[kMAXDIGITS];//contributing tracks for the current slot
	
	  Float_t tdc=tofsdigit->GetTdc(islot); digit[0]=tdc;
	  Float_t adc=tofsdigit->GetAdc(islot); digit[1]=adc;

	  tracknum[0]=tofsdigit->GetTrack(islot,0);
	  tracknum[1]=tofsdigit->GetTrack(islot,1);
	  tracknum[2]=tofsdigit->GetTrack(islot,2);

	  for (Int_t i = 0; i < kMAXDIGITS; i++) {
	    tottracks++;
	    // search for the first empty location
	    if(tracknum[i]==-1){
	      tottracks--;
	      break;
	    }
	  }

	  // adding a TOF digit for each slot
          {
          Int_t ndigits=da.GetEntriesFast();
	  new (da[ndigits]) AliTOFdigit(tracknum, vol, digit);
          }          
	  totndig++;
	}


      } // end loop on sdigits
      fSDigits->Clear();
      
    } // end loop on entries

    dTree->Fill();
    tofl->WriteDigits("OVERWRITE");

    // free used memory
    fDigits->Clear();

  } // end loop on events 

  delete fSDigits;
  delete fDigits;
  
  tofl->UnloadDigits();
  tofl->UnloadSDigits();
  rl->UnloadHeader();
  rl->UnloadgAlice();
  
  cout << "----------------------------------------------------------" << endl;
  cout << "<AliTOFSDigits2Digits> Summary" << endl;
  cout << "contributing tracks to " << totndig << " digits: " << tottracks << endl; 
  cout << "----------------------------------------------------------" << endl;

  if (gAlice)
    {
      delete gAlice->GetRunLoader();
      delete gAlice;
      gAlice = 0x0;
    }

  return rc;

}