flyopunta/src/src_main/filemg.cpp

Go to the documentation of this file.

/***************************************************************************
                          filemg.cpp  -  description
                             -------------------
    begin                : Sun Dec 10 2000
    copyright            : (C) 2000 by Giuseppe M Pierazzini
    email                : pierazzini@unipi.it
 ***************************************************************************
 *                                                                         *
 *   NA48   simulation program.                                             *
 *                                                                         *
 ***************************************************************************/

// CP violation  program...... in Obj!!     Tirrenia 27.07.00

//-----------------------------------------------------------
#include "parm.h"
#include "ctype.h"
#include "evento.h"
#include <getopt.h>
#include <dirent.h>     /* Directory information. */

//-----------------------------------------------------------
using namespace std;



void Print_Help()
{
  printf ( "\nUsage:  Flyo [-opzioni] " );
  printf ( "\n\t-h Help:  write this help message" );
  printf ( "\n\t-p Pipeline yes/si/no [no] " );
  printf ( "\n*\t-i InPath/input_file " );
  printf ( "\n*\t-d OutPath directory  " );
  printf ( "\n*\t-t Data out type: root,hroot,null" );
  printf ( "\n\t-r run  number" );
  printf ( "\n\t-e Max event number" );
  printf ( "\n\t-b First gas_reaction to be read from file" );  
  printf ( "\n\nnote:\t* field could not be empty!" );
  printf ( "\n\tdefine the absolute paths  or \n\trelative to the Flyo working  directory" );
  printf ( "\n\tThe apparatus file is usully included at the end of epc file." );
  printf ( "\n --------    end    ------" );
  printf ( "\n" );
  exit ( 0 );
}
//----------------------------------------------------------
void File_Manager()
{
// char *OutDir=0;
  string Versione="V 2010  Psa " ;
  printf ( "\n----------------------------------------------------------------" );
  printf ( "\n ************************************************************** " );
  printf ( "\n****                                            Pisa 2006   ****" );
  printf ( "\n***                                                          ***" );
  printf ( "\n**               C++   F L Y O        Running                 **" );
  printf ( "\n***                                                          ***" );
  printf ( "\n****                                  < by GmP/LF/SG/Am >   ****" );
  printf ( "\n ************************************************************** " );
  printf ( "\n                                  **" );
//


  if ( gargc<2 )
    {
      cout <<"\n  Input  error: no input parameters...\n";
      Print_Help();
    }

  int inparm=0;


  int o;
  while ( ( o = getopt ( gargc, gargv, "p:d:i:t:r:e:b:l:h" ) ) !=-1 )
    {
      switch ( o )
        {
        case 'h':
          Print_Help();
          break;

        case 'p':
          if ( strncmp ( optarg,"si",2 ) ==0 ) Pipeline=1;
          if ( strncmp ( optarg,"yes",2 ) ==0 ) Pipeline=1;
          cout<<  "\n Pipeline status      ==> "<< ( Pipeline?"on":"off" );
          //Pipeline time window =0.250 ns fixed in tempo.h
          fflush ( stdout );
          break;


        case 'd':
          OutDir= new char[strlen ( optarg ) +2];
          strcpy ( OutDir,optarg );
          printf ( "\n Output Directory by operator  ==> %s",OutDir );
          inparm++;
          break;

        case 'b':
          GasBegin= atol ( optarg );
          printf ( "\n First Gas event from file  ==> %d",GasBegin );
          inparm++;
          break;

        case 'i':
          Cardin= new char[strlen ( optarg ) +2];
          strcpy ( Cardin,optarg );
          printf ( "\n Input file by operator        ==> %s",Cardin );
          inparm++;
          break;

        case 't':
          Wrt_type_out=optarg;
          cout<<"\n Data out type                 ==> "<<Wrt_type_out;
          break;

        case 'r':
          evento_.Gen.Run = atol ( optarg );
          printf ( "\n Run num. defined by operator  ==> %d", evento_.Gen.Run );
          fflush ( stdout );
          break;

        case 'e':
          evento_.Mxev= atol ( optarg );
          printf ( "\n MaxEvents defined by operator ==> %d",evento_.Mxev );
          fflush ( stdout );
          break;

        default:
          printf ( "errore nella linea di comando\n" );
          exit ( -1 );
          break;
        }
    }
  if ( inparm<2 )
    {
      cout<<"\n\n\n  Error: Not enough input parameters!";
      Print_Help();
    }
  cout<<"\n------ End input parsing --------"<<endl;

// get run by string
  stringstream  ostr;
  string Srun;
  ostr<<evento_.Gen.Run;
  ostr>>Srun;

//=============  define the  nt files or the binary file ==================
// default out file dipendente dal run ...
//    char *OutGn_byrun=new char[256];

  string OutGn_byrun;

  if ( Wrt_type_out=="root" )
    {
      OutGn_byrun= "Fly_"+Srun+".root";
//        sprintf ( OutGn_byrun,"fly_%d.root",evento_.Gen.Run );
      Wrtype=1;
    }
  else if ( Wrt_type_out=="hroot" )
    {
      OutGn_byrun= "Fly_h"+Srun+".root";

//        sprintf ( OutGn_byrun,"fly_h%d.root",evento_.Gen.Run );
      Wrtype=2;
    }
  else if ( Wrt_type_out=="null" )
    {
      OutGn_byrun= "Fly_null"+Srun+".root";
//        sprintf ( OutGn_byrun,"fly_null%d.gn",evento_.Gen.Run );
      Wrtype=0;
    }
  else if ( Wrt_type_out=="paw" ||Wrt_type_out=="hpaw" )
    {
      cout<<" \n  Attenzione.... Paw è obsoleto..si usa root: exit!?"<<endl ;
      exit ( 0 );
    }

  else
    {
      printf ( "\n ERROR File di output non defined, \n Pls set \" -t  root, hroot or null\"  in command line!" );
      exit ( 0 );

    }


  if ( OutDir )
    {
      check_file_name ( OutDir,OutGn_byrun );
      sprintf ( OutGn,"%s/%s",OutDir,OutGn_byrun.c_str() );  // Flyo running
    }
  else
    {
      check_file_name ( ".",OutGn_byrun );

      sprintf ( OutGn,"./%s",OutGn_byrun.c_str() );
    }
  cout<<"\n Results file (by run):        ==>  "<<OutGn_byrun;
//     define the nt out dir/file
  cout<<"\n Out location (list,hbook...): ==>  "<<OutDir;
  cout<<"\n Program name:                 ==>  "<<gargv[0];
  cout<<"\n Program Version:              ==>  "<<Versione;
  cout<< "\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^" ;
  cout<<"\n ===================================================\n";

//============= define the output list file=================

// char *Lista_nome=new char[256];

  string Serie;
  Serie=OutGn_byrun;
  string Lista_nome;
  Lista_nome=OutDir;
  if ( OutDir )
    {
      Serie=Serie.substr ( Serie.find ( "." ) +1,Serie.size() );
      Serie=Serie.substr ( 0,Serie.find ( "." ) );
      Lista_nome+="/list"+Srun+"."+Serie+".txt";
    }
  else  Lista_nome ="list"+Srun+"."+Serie+".txt"; //default

// redirect the standard output to the file Lista
  cout<< "\n You may continue to  read the Flyo output lista in\n   ==>  "<<Lista_nome;
  cout<< "\n -----------------------------\n" ;

//***********************************************************************************
//*********************************************************************************
// uscita in list di debug....
//***************************************
  Gout.open ( Lista_nome.c_str() ,ios::out );

//********************************
  if ( Gout )
    {
      Gout<<"\n----------------------------------------------------------------";
      Gout<<"\n ************************************************************** ";
      Gout<<"\n****                                            Pisa 2006  ****";
      Gout<<"\n***                                                          ***";
      Gout<<"\n**               C++   F L Y O        Running                 **";
      Gout<<"\n***                                                          ***";
      Gout<<"\n****                                  < by GmP/LF/SG/Am >   ****";
      Gout<<"\n ************************************************************** ";
      Gout<<"\n                                  **";
      Gout<<"\n Program name:                 ==> "<<gargv[0];
      Gout<<"\n Program Version:              ==> "<<Versione;
      if ( OutDir )      Gout<<"\n Output Directory by operator  ==> "<<OutDir;
      if ( Cardin )      Gout<<"\n Input file by operator        ==> "<<Cardin;
      if ( evento_.Gen.Run ) Gout<<"\n Run number                    ==> "<<evento_.Gen.Run;
      if ( evento_.Mxev ) Gout<<"\n MaxEvents                     ==> "<<evento_.Mxev;
    }
  Gout<<"\n ----------";

//=============  data output file ==================

  Gout<<"\n Out data file :                   ==> "<<OutGn;
  Gout<<"\n ==============\n";
  Gout<<"\n Output list:                  ==> "<<Lista_nome;
  time_t tck;
  time_t clockstart=time ( &tck );
  Gout<<"\n Flyo starts output list       ==> "<<ctime ( &clockstart );
  Gout<<"\n Flyo  input base .epc file    ==> "<<Cardin;

  Legge_input_file ( Cardin );
// end reading input files......

}


void check_file_name ( const char *outdir, string &filename )
{
//  Inserisce una flag di serie nelle file di uscita per non sovrascrivere le vecchie...
  /* Open the current directory   */
  DIR     *dir_p;
  struct dirent *dir_entry_p;
  dir_p = opendir ( outdir );
  string dirfile, dpref,dserie,dsuff;

  string prefisso, suffisso,inputfile;
  int serie=-1;
//   filename                                         // tipo fly_Run.root
  prefisso=filename.substr ( 0,filename.find ( "." ) );     //  fly_Run
  suffisso=filename.substr ( filename.find ( "." ) +1,filename.size() );// root
  while ( 0 != ( dir_entry_p = readdir ( dir_p ) ) )
    {
      dirfile= dir_entry_p->d_name;    //tipo fly_Run.xx.root
      int dpos1=dirfile.find ( "." );
      int dpos2=dirfile.rfind ( "." );
      dpref=dirfile.substr ( 0,dpos1 );   //    fly_Run
      if ( dpos2>dpos1 )
        dserie=dirfile.substr ( dpos1+1,dpos2-dpos1-1 ); //   xx
      else dserie="";
      dsuff=dirfile.substr ( dpos2+1,dirfile.size() );         // root

      if ( dpref==prefisso&& dsuff==suffisso )
        {
          // estraggo la serie e ricordo la massima
          stringstream ostr;
          ostr<<dserie;
          int lets=0;
          ostr>>lets;
          if ( lets>serie ) serie=lets;
        }

    }
  closedir ( dir_p );
//     if (serie>-1)
//     {
// aggiungo la serie+1  al filename.
  serie++;
  dserie="";
  inputfile="";
  stringstream ostr;
  ostr<<serie;
  ostr>>dserie;
  inputfile= prefisso+"."+dserie+"."+suffisso;
  filename=inputfile;
  // }

}