Ntuplize.cxx

Go to the documentation of this file.

// Authors: M.Duranti - INFN di Perugia
//          P. Zuccon - MIT 
#include <unistd.h> 
#include <cstdio>
#include <iostream>
#include <signal.h>
#include <getopt.h>

#include "root_RVSP.h"
#include "amschain.h"

#include <TFile.h>
#include <TKey.h>
#include <TTree.h>
#include <Compression.h>

#include <TrRecon.h>

#include "debug.h"
#include "myChain.h"
#include "myInfo.h"
#include "myRTI.h"
#include "myStatus.h"
#include "myHeader.h"
#include "myEvent.h"
#include "myParticle.h"
#include "myMC.h"
#include "myBeta.h"
#include "myBetaH.h"
#include "myTrdTrack.h"
#include "myTrdTrackPlus.h"
#include "myTrdK.h"
#include "myTrdQtFromTrTrack.h"
#include "myRichRing.h"
#include "myEcalShower.h"
#include "myTrTrack.h"
#include "myTrTrackPlus.h"
#include "myEcalShowerPlus.h"
#include "myRichRingPlus.h"
#include "myBetaPlus.h"
#include "myBetaHPlus.h"

using namespace std;

#define _SELECT_ALL_

void shandler(int sig);
int main(int argc, char* argv[]);
TString CreateOutputFileName(TTree* _InputTree);
bool GoodEventToBeNtuplized(AMSEventR* ev);

volatile bool stoploop=false;
void shandler(int sig){
  stoploop=true;
  clog << "\033[1;33;44signal received. You want to quit?\033[0m\n";
  return;
}

//--------------------------------------------------------------------
//  Command line options
#include "config.hxx"
struct gargs_t {
  int num;
  int start;
  //char odir[200];
  TString odir;
  bool noecalplus;
  bool notrackerplus;
  bool notrdqtplus;
  gargs_t() {
    num=-1;
    start=0;
    //sprintf(odir,"./");
    odir = "./";
    //noecalplus=false;
    //notrackerplus=false;
    //notrdqtplus=false;
  }
} gargs;

static struct option long_options[] = {
  {"noecalplus",       no_argument,       0, 'e'},
  {"notrackerplus",    no_argument,       0, 't'},
  {"disable",    required_argument, nullptr, 'd'},
  {"produce",    required_argument, nullptr, 'p'},
  {"nevents",    required_argument,       0, 'n'},
  {"start",      required_argument,       0, 's'},
  {"outdir",     required_argument,       0, 'o'},
  {"help",             no_argument,       0, 'h'},
  {0, 0, 0, 0}// we have to put this 4 elements array to indicate the end of option array...
};

void _usage(char * name){
  fprintf(stderr, "Usage:\t %s [-n <max_ev>] [-s <start_ev>] [-o <output_dir>] input_file_name1 input_file_name2 ...\n",name);
  fprintf(stderr, "Options:\n");
  fprintf(stderr, "\t -n, --nevents num      \t Max number of event (default: all)\n");
  fprintf(stderr, "\t -s, --start   num      \t Start from event number  (default: 0)\n");
  fprintf(stderr, "\t -o, --outdir  out_dir  \t The output dir for the DST files \n");
  fprintf(stderr, "\t                        \t (default: ./ )\n");
  fprintf(stderr, "\t -e, --noecalplus       \t Not produces EcalPlus tree\n");
  fprintf(stderr, "\t -t, --notrackerplus    \t Not produces TrackerPlus tree\n");
  fprintf(stderr, "\t -d, --disable <section>\t Disable producing of a section\n");
  fprintf(stderr, "\t -p, --produce <section>\t Only produce one section\n");
  exit(1);
}
  
int _proc_args(int argc, char *argv[]) {
  int c;
  int def=0;
  /* Turn off error check for getopt */
  //opterr = 0;

  /* getopt_long stores the option index here. */
  int option_index = 0;
  
  printf("--------------------------------------------------\n");

  /* Loop on options */
  while (1) {
    c = getopt_long (argc, argv, "s:n:o:p:d:het", // XXX must sync with long_options
                     long_options, &option_index);
    //    c = getopt(argc, argv, "s:n:o:d:p:h?et");
    if (c == -1) break;
    switch (c) {
    case 'n':
      printf("Processing %d events\n", atoi(optarg));
      gargs.num=atoi(optarg);
      def++;
      break;
    case 's':
      printf("Starting from event %d\n", atoi(optarg));
      gargs.start=atoi(optarg);
      def++;
      break;
    case 'o':
      printf("Writing the output files in %s\n", optarg);
      //sprintf(gargs.odir,"%s", optarg);
      gargs.odir = optarg;
      def++;
      break;
    case 'e':
      printf("Not producing EcalPlus tree\n");
      //gargs.noecalplus=true;
      gsection.disable("EcalPlus");
      def++;
      break;
    case 't':
      printf("Not producing TrackerPlus tree\n");
      gargs.notrackerplus=true;
      gsection.disable("TrackerPlus");
      def++;
      break;
    case 'd':
      printf("Disabling section %s\n", optarg);
      if(not gsection.disable(optarg))
        printf("Warning: Uknown section %s\n", optarg);
      ++def;
      break;
    case 'p':
      printf("Only produce section %s\n", optarg);
      if(!gsection.enable_only(optarg)){
        printf("Fatal: Unknown section %s, can not continue...\n", optarg);
        exit(2);
      }
      ++def;
      break;
    case 'h':
      //      printf ("option -h\n");
      return -1;
    case '?': //case '?' is triggered also when the opt is not recognized 
    default:
      printf("!!! Unknown option found !!!\n");
      return -999;
    }
  }
 
  printf("--------------------------------------------------\n");

  /*
  // Print any remaining command line arguments (not options).
  if (optind < argc) {
    int optind_ = optind;
    printf ("non-option ARGV-elements: ");
    while (optind_ < argc)
      printf ("%s ", argv[optind_++]);
    putchar ('\n');
  }
  */
  
  //  printf("Returning %d (%d)...\n", def, argc);//only for debug
  return def;
}

//--------------------------------------------------------------------
int main(int argc, char* argv[]){

  PRINTDEBUG;

  signal(SIGTERM, shandler);
  signal(SIGINT, shandler);

  PRINTDEBUG;

  // Process command line input arguments 
  int istat = _proc_args(argc, argv);
  int residualargc = (argc-optind);
  // printf("residual argc = %d\n", residualargc);//only for debug
  // printf("istat = %d\n", istat);//only for debug
  // Error from command line 
  if (istat<0 || residualargc<=0) {
    if (istat<-1) fprintf(stderr, "Error: from the command line\n"); // -1 for help
    _usage(argv[0]);
    exit(1);
  }

  PRINTDEBUG;

  AMSChain* ams = new AMSChain();
  for (int ii=optind; ii<argc; ii++) {
    //    ams->Add(Form("root://castorpublic.cern.ch/%s?svcClass=amsuser", argv[ii]));
    TString fn = argv[ii];
    /* some tricky on eos and castor files */
    if( fn.BeginsWith("/eos/") ) fn.Prepend( "root://eosams.cern.ch/" );
    if( fn.BeginsWith("/castor/") ) fn.Prepend( "root://castorpublic.cern.ch/" );
    if( fn.BeginsWith("root://castorpublic") and not fn.Contains("svcClass=amsuser") ) {
      if( fn.Contains("?") ) // already have opt
        fn.Append("&svcClass=amsuser");
      else
        fn.Append("?svcClass=amsuser");
    }
    /* end of the tricky... */
    ams->Add(fn);
    static Long64_t oldentries=0;
    Long64_t nentries = ams->GetEntries();
    printf("Added rootupla = %s (%lld entries)\n", argv[ii], nentries-oldentries);
    oldentries=nentries;
  }

  PRINTDEBUG;

  printf("TChain (%s) with %lld entries\n", ams->ClassName(), ams->GetEntries());

  PRINTDEBUG;

  Long64_t nentries = ams->GetEntries();
  Long64_t start=gargs.start;
  Long64_t stop=nentries;
  if (gargs.num>0) stop=start+gargs.num;
  if (stop>nentries) stop=nentries;
  //  start=0; nentries=10000;
  //  start=0; nentries=10;
  //  start=6; nentries=1;
  //  start=96; nentries=1;
  //  start=3863;nentries=1; 

  PRINTDEBUG;

  gargs.notrdqtplus=true;//TrdQtPlus disabled by default

  PRINTDEBUG;

  //char filename_base[1024];
  //sprintf(filename_base, "%s/%s", gargs.odir, CreateOutputFileName(ams));
  TString filename_base = gargs.odir + "/" + CreateOutputFileName(ams);
  std::vector<string> suffix;
  std::vector<string> branchname;
  suffix.assign( gsection.enabled_sections.begin(), gsection.enabled_sections.end() );
  /*
  suffix.push_back("MainTree");      branchname.push_back("fmyEvent");      
  suffix.push_back("TRDPlus");       branchname.push_back("vmup");
  suffix.push_back("TRDKPlus");       branchname.push_back("vmukp");
  if (!(gargs.notrdqtplus)) {
    suffix.push_back("TRDQtPlus");   branchname.push_back("vmuqtp");
  }
  if (!(gargs.noecalplus)) {
    suffix.push_back("EcalPlus");    branchname.push_back("vmep");
  }
  suffix.push_back("BetaPlus");      branchname.push_back("vmbp");
  suffix.push_back("BetaHPlus");     branchname.push_back("vmbhp");
  suffix.push_back("RichPlus");      branchname.push_back("vmrp");
  if (!(gargs.notrackerplus)) {
    suffix.push_back("TrackerPlus"); branchname.push_back("vmtp");
  }
  suffix.push_back("StatusTree");    branchname.push_back("ms");
  suffix.push_back("RTI");           branchname.push_back("RTI");                 
  */
  int n_branches=suffix.size();
  TFile* f[n_branches];

  PRINTDEBUG;

  //--------------------------------------------
  myObject::Class()->IgnoreTObjectStreamer();

  myEvent::Class()->IgnoreTObjectStreamer();

  myParticle::Class()->IgnoreTObjectStreamer();

  myTrdTrack::Class()->IgnoreTObjectStreamer();
  myEcalShower::Class()->IgnoreTObjectStreamer();
  myBeta::Class()->IgnoreTObjectStreamer();
  myBetaH::Class()->IgnoreTObjectStreamer();
  myRichRing::Class()->IgnoreTObjectStreamer();
  myTrTrack::Class()->IgnoreTObjectStreamer();

  myTrdK::Class()->IgnoreTObjectStreamer();
  myTrdQtFromTrTrack::Class()->IgnoreTObjectStreamer();
  myEcalShowerPlus::Class()->IgnoreTObjectStreamer();
  myBetaPlus::Class()->IgnoreTObjectStreamer();
  myBetaHPlus::Class()->IgnoreTObjectStreamer();
  myRichRingPlus::Class()->IgnoreTObjectStreamer();
  myTrTrackPlus::Class()->IgnoreTObjectStreamer();
  myTrdTrackPlus::Class()->IgnoreTObjectStreamer();

  myInfo::Class()->IgnoreTObjectStreamer();

  myRTI::Class()->IgnoreTObjectStreamer();

  myMC::Class()->IgnoreTObjectStreamer();

  myHeader::Class()->IgnoreTObjectStreamer();

  myStatus::Class()->IgnoreTObjectStreamer();
  //--------------------------------------------

  int complevel=ROOT::CompressionSettings(ROOT::kLZMA, 2);

  TTree* t3[n_branches];
  myEventFiller* me = myEventFiller::gethead();
  //if (gargs.noecalplus) myEventFiller::NoEcalPlus=true;
  //if (gargs.notrackerplus) myEventFiller::NoTrackerPlus=true;
  //if (gargs.notrdqtplus) myEventFiller::NoTRDQtPlus=true;
  myEvent* mf = me->getfather();
  //  printf("%s\n", me->GetName());

  PRINTDEBUG;

  UInt_t run = 0;
  UInt_t evtnum = 0;
  UInt_t timejmdc = 0;

  myInfo myruninfo;

  PRINTDEBUG;

  std::vector<myTrdTrackPlus*>* vmup = &(mf->vmup);
  std::vector<myTrdK*>* vmuktp = &(mf->vmuktp);
  std::vector<myTrdK*>* vmukup = &(mf->vmukup);
  std::vector<myTrdQtFromTrTrack*>* vmuqtp = &(mf->vmuqtp);
  std::vector<myEcalShowerPlus*>* vmep = &(mf->vmep);
  std::vector<myBetaPlus*>* vmbp = &(mf->vmbp);
  std::vector<myBetaHPlus*>* vmbhp = &(mf->vmbhp);
  std::vector<myRichRingPlus*>* vmrp = &(mf->vmrp);
  std::vector<myTrTrackPlus*>* vmtp = &(mf->vmtp);

  PRINTDEBUG;
  
  branchname.resize(n_branches);
  for (int ii=0; ii<n_branches; ii++) {
    section_t::mssit smit = gsection.sections_map.find( suffix[ii] );
    if( smit == gsection.sections_map.end() ){
      printf("Unknown section %s, skipping...\n", suffix[ii].c_str());
      continue;
    }
    branchname[ii] = smit->second;
    //char filename[1024];
    //sprintf(filename,"%s_%s.root", filename_base.Data(), suffix[ii].c_str());
    TString filename = filename_base+"_"+suffix[ii]+".root";
    printf("Opening %s...\n", filename.Data());
    f[ii] = new TFile(filename, "recreate", "File with Ntuplized AM1SRoot Tree", complevel);
    f[ii]->cd();
    
    if(branchname[ii]=="fmyEvent") t3[ii] = new TTree("AMSRootNtuplized", Form("AMSRootNtuplized (%s)", suffix[ii].c_str()));
    else t3[ii] = new TTree(Form("AMSRootNtuplized_%s", suffix[ii].c_str()), Form("AMSRootNtuplized (%s)", suffix[ii].c_str()));
    
#ifdef PDEBUG
    printf("Creating branch %s...\n", branchname[ii].c_str());
#endif
    
    if(branchname[ii]=="fmyEvent") {
      // without this "myEvent" also myEventFiller is written on disk
      // since the Branch constructor auto-identifies it as myEventFiller (actually it is...)
      //      printf("name=%s, classname=%s\n", mf->GetName(), mf->ClassName());
      t3[ii]->Branch(branchname[ii].c_str(), "myEvent", &mf, 32000, 100);
    }
    else if(branchname[ii]=="ms") {
      t3[ii]->Branch(branchname[ii].c_str(), &(mf->ms), 32000, 100);
    }
    else if(branchname[ii]=="RTI") {
      t3[ii]->Branch(branchname[ii].c_str(), &(mf->RTI), 32000, 100);
    }
    /*
    // with 32000, 101 the vector is put in a sub-vector making it more difficult to be reached via CINT
    // maybe it was the meaning of http://root.cern.ch/root/html/TTree
    // ==> Case E
    // TBranch *branch = tree->Branch( branchname, STLcollection, buffsize, splitlevel);
    // STLcollection is the address of a pointer to std::vector, std::list,
    // std::deque, std::set or std::multiset containing pointers to objects.
    // If the splitlevel is a value bigger than 100 (TTree::kSplitCollectionOfPointers)
    // then the collection will be written in split mode, e.g. if it contains objects of
    // any types deriving from TTrack this function will sort the objects
    // based on their type and store them in separate branches in split
    // mode.
    */ 
    else if(branchname[ii]=="vmup") {
      t3[ii]->Branch(branchname[ii].c_str(), "std::vector<myTrdTrackPlus*>", &vmup, 32000, 100);
    }
    else if(branchname[ii]=="vmukp") {
      t3[ii]->Branch("vmuktp", "std::vector<myTrdK*>", &vmuktp, 32000, 100);
      t3[ii]->Branch("vmukup", "std::vector<myTrdK*>", &vmukup, 32000, 100);
    }
    else if(branchname[ii]=="vmuqtp") {
      t3[ii]->Branch(branchname[ii].c_str(), "std::vector<myTrdQtFromTrTrack*>", &vmuqtp, 32000, 100);
    }
    else if(branchname[ii]=="vmep") {
      t3[ii]->Branch(branchname[ii].c_str(), "std::vector<myEcalShowerPlus*>", &vmep, 32000, 100);
    }
    else if(branchname[ii]=="vmbp") {
      t3[ii]->Branch(branchname[ii].c_str(), "std::vector<myBetaPlus*>", &vmbp, 32000, 100);
    }
    else if(branchname[ii]=="vmbhp") {
      t3[ii]->Branch(branchname[ii].c_str(), "std::vector<myBetaHPlus*>", &vmbhp, 32000, 100);
    }
    else if(branchname[ii]=="vmrp") {
      t3[ii]->Branch(branchname[ii].c_str(), "std::vector<myRichRingPlus*>", &vmrp, 32000, 100);
    }
    else if(branchname[ii]=="vmtp") {
      t3[ii]->Branch(branchname[ii].c_str(), "std::vector<myTrTrackPlus*>", &vmtp, 32000, 100);
    }
  
    // I don't think it's needed
    // if(branchname[ii]=="fmyEvent" || branchname[ii].find("PlusVector")!=std::string::npos)
    //   t3[ii]->BranchRef();

    TBranch * branch = t3[ii]->GetBranch(branchname[ii].c_str());
    if (branch) branch->SetCompressionLevel(6);
    if (branchname[ii]!="RTI") {
#ifdef PDEBUG
      printf("Adding Run and Event branches...\n");
#endif
      t3[ii]->Branch("Run", &run);
      t3[ii]->Branch("Event", &evtnum);
    }
    if (branchname[ii]=="RTI" || branchname[ii]=="fmyEvent") {
#ifdef PDEBUG
      printf("Adding Time branch...\n");
#endif
      t3[ii]->Branch("Time", &timejmdc);
    }
    
    t3[ii]->SetAutoSave(100000000);//100MB
    t3[ii]->AutoSave("SaveSelf,Overwrite");
  }
  
  PRINTDEBUG;

  AMSEventR* ev = ams->GetEvent(0);

  PRINTDEBUG;

  int perc=1;
  long long int accepted=0;

  PRINTDEBUG;

  bool IsMC= (ev->nMCEventg()>0)?true:false,
       IsISS = not IsMC and ev->Run() > 1305795600,
       IsTB  = not IsMC and ev->Run() < 1305795600;
  if(!IsMC){
    TkDBc::UseLatest();    
  }else{
    AMSSetupR::LoadISSMC=false;
  }
  if(!IsISS){
     AMSSetupR::SlowControlR::ReadFromExternalFile = false;
     if(IsTB)
       TrdKCluster::IsReadGlobalAlignment = false;
     if(IsMC){ // according to twiki
       TrdKCluster::ForceReadCalibration = false;
       TrdKCluster::ForceReadAlignment = false;
     }
  }

  // non serve più a un cazzo, FORSE, e però messo nel costruttore mi fà inizializzare un TkDBc con l'allineamento nominale
  // TRFITFFKEY.ReadFromFile = 0;//this should avoid the automatic reading of TRFITFFKEY from the rootuple
  // TRFITFFKEY.init();
  // lo faccio qui che se lo faccio nel costruttore inizializza il TkDBc con l'allineamento nominale
  //  if (!(TkDBc::Head)) {
  //    TkDBc::CreateTkDBc();
  //    TkDBc::Head->init();
  //  }
  
  PRINTDEBUG;


  Long64_t jentry=0;
  for (jentry=start; jentry<(stop); jentry++) {
    
    PRINTDEBUG;

    ams->GetEvent(jentry);
    //printf("Got Event %9d\n",jentry);
    Double_t pperc=(100.0*((jentry-start)+1))/(stop-start);
    
    PRINTDEBUG;

    if (GoodEventToBeNtuplized(ev)) {
      accepted++;
      run = ev->Run();
      evtnum = ev->Event();
      HeaderR* head = &(ev->fHeader);
      timejmdc = head->Time[0];
#ifdef PDEBUG
      printf("%lld) @@@@@@@@@@@@@@@@@@@  Run=%d, Event=%d\n", jentry, ev->Run(), ev->Event());
#endif

#ifdef PDEBUG
      printf("Accepted %9lld\n",jentry);
#endif
      PRINTDEBUG;
      
      if (IsMC) {
        TRMCFFKEY.NoiseType=1; // NEW LINE
        TRCLFFKEY.UseSensorAlign=1;
      }

      PRINTDEBUG;
      TofRecH tofrec;
      tofrec.ReBuild();
      PRINTDEBUG;

      static TString origfile="";
      Long64_t treeentrynumber = ams->GetTree()->GetReadEntry();
      int treenumber = ams->GetTreeNumber();
      TString currfile = ams->GetTree()->GetCurrentFile()->GetName();
      if (currfile!=origfile) {
        origfile=currfile;
#ifdef PDEBUG
        printf("%lld) @@@@@@@@@@@@@@@@@@@@@@@@ %s %d %lld\n", jentry, origfile.Data(), treenumber, treeentrynumber);
#endif
        myruninfo.OriginalFiles.push_back(origfile);
      }
#ifdef PDEBUG
      printf("Filling myEvent...\n");
#endif
      me->Fill(treenumber, treeentrynumber);
#ifdef PDEBUG
      printf("myEvent filled...\n");
#endif
      //  for (int jj=0; jj<me->vmt.size(); jj++) printf("%d) vmt[%d]: iPart()=%d, iMySelf()=%d, i_part=%d, i_myself=%d\n", me->Event, jj, me->vmt[jj].iPart(), me->vmt[jj].iMySelf(), me->vmt[jj].i_part, me->vmt[jj].i_myself);//only for debug
      
      PRINTDEBUG;
      
#ifdef PDEBUG
      printf("Ntuplize: %d\n", evtnum);
      //      printf("Ntuplize: %d -- %d\n", evtnum, me->RTI->evno);
#endif
      
      PRINTDEBUG;

      for (int jj=0; jj<n_branches; jj++) {
        PRINTDEBUG;
#ifdef PDEBUG
        printf("Filling branch %d (%s)...\n", jj, branchname[jj].c_str());
#endif
        PRINTDEBUG;
        if (!t3[jj]) continue;
        PRINTDEBUG;
        if (branchname[jj]!="RTI") {
          PRINTDEBUG;
          t3[jj]->Fill();
        }
        else if (me->RTI) {
          PRINTDEBUG;
          t3[jj]->Fill();
        }
        PRINTDEBUG;
      }
      PRINTDEBUG;
    }
    
    PRINTDEBUG;
    
    if (pperc>=perc) {
      printf("Processed %lld out of %lld: %d%% (accepted %lld, %d%%)\n", (jentry+1-start), stop-start, (int)perc, accepted, (int)((100.0*accepted)/(stop-start)));
      fflush(stdout);
      perc+=perc<10?1:10;
    }
    
    PRINTDEBUG;
   
    if (stoploop) break;
  }
  printf("Processed %lld out of %lld: %d%% (accepted %lld, %d%%)\n", (jentry+1-start), stop-start, (int)perc, accepted, (int)((100.0*accepted)/(stop-start)));
  
  for (int ii=0; ii<n_branches; ii++) {
    PRINTDEBUG;
    if (branchname[ii]!="fmyEvent" && branchname[ii]!="RTI") {
      printf("Building index for TTree %d...\n", ii);
      t3[ii]->BuildIndex("Run", "Event");
    }
    else if (branchname[ii]=="RTI") {
      printf("Building index for TTree %d...\n", ii);
      t3[ii]->BuildIndex("Time");
    }
    //-------------------when the TList::Delete (or just delete?!) is called,
    //  even with the following, the object contained is destroyed-----------
    t3[ii]->GetUserInfo()->SetOwner(kFALSE);
    //-----------------------------------------------------------------------
    t3[ii]->GetUserInfo()->Add(&myruninfo);
    PRINTDEBUG;
  }

  for (int ii=0; ii<n_branches; ii++) {
    f[ii]->Write(0, TObject::kOverwrite);
    PRINTDEBUG;
    t3[ii]->GetUserInfo()->Clear("nodelete");//in this way the object in TList are removed (but now the TList is written!) and no destructor is called...
    PRINTDEBUG;
    printf("Closing file %s (%d)...\n", f[ii]->GetName(), ii);
    f[ii]->Close();
    PRINTDEBUG;
  }
  
  return 0;
}

TString CreateOutputFileName(TTree* _InputTree){
  //char* filename = new char[1024];
  //sprintf(filename,"dummyname_ntuplized.root");//fault back
  TString filename = "dummyname_ntuplized.root"; //
  
  if (_InputTree==0){
    printf(" Ntuplize::CreateOutputFileName: The input tree pointer is empty\n");
    exit(1);
  }
  else  {
    TFile* rootfile=0;
    
    ((TTree*)_InputTree)->GetEvent(0); //otherwise the file can be not retrieved if no event was read
    
    if (((TTree*)_InputTree)->GetEntries() != 0) {
      rootfile = ((TTree*)_InputTree)->GetCurrentFile();
    }
    
    if (!rootfile) {
      printf("The passed TTree/TChain doesn't contain any event! Did you already make TChain::Add()?!\n");
    }
    else {
      //      printf("%s %p %s\n", _InputTree->GetName(), rootfile, rootfile->GetName());//only for debug
      TString s(rootfile->GetName());
      TString striped;
      TObjArray* array = s.Tokenize("/");
      for (int ii=0; ii<array->GetEntries(); ii++) {
        TString temp = ((TObjString*)array->At(ii))->GetString();
        //      printf("ii) %s\n", temp.Data());//only for debug
        if (temp.Contains(".root")) striped=temp; //I don't put a break since if the user put the file.root in a directory
        //called directory.root the loop will last up to the end of the array and "directory.root" will be overwritten
        //by the correct one "file.root"
      }
      array->SetOwner(kTRUE);
      striped.ReplaceAll(".root", "");
      //      printf("name = %s\n", striped.Data());//only for debug
      //sprintf(filename, "%s", striped.Data());
      filename = striped;
      delete array;
      array=0;
    }
  }
  
  return filename;
}

bool GoodEventToBeNtuplized(AMSEventR* ev){
  //whatever kind of selection is needed
  PRINTDEBUG;
  return true;
  PRINTDEBUG;
}

// vim: sw=2