DAQ++ git-vmedaq

#include <iostream>
#include <iomanip>
#include <csignal>
#include <cstdio>
#include <getopt.h>
#include <DAQ++/DAQmanager.h>
#include <DAQ++/RunState.h>
#include <daq/PedestalRunManager.h>
#include <daq/PulseRunManager.h>
#include <daq/DataRunManager.h>
#include <daq/IntTrgRunManager.h>
#include <daq/ScanPoint.h>
#include <daq/GenModule.h>
#include <config/Config.h>

#include <gui/WidgetUpdate.h>
UpdateLabelRate __w(0);


typedef enum {
   DATA,
   PEDESTAL,
   INT_TRG,
   PULSE,
   LAST
} RMtype;

RMtype RunType;
const char *Rnames[] = { 
   "DataRunManager",
   "PedestalRunManager",
   "IntTrgRunManager",
   "PulseRunManager",
   0
};
std::string sRunManager;

bool DoRun = true;
void quit(int ) {
//   signal(SIGINT,SIG_DFL);
   std::cout << std::endl << "Run stop forced" << std::endl;
   DoRun=false;
}
int parse_cmd_line(int argc, char **argv);

enum ROmode { serial=2,sparse=4,sparse_adj=8 };
bool doPedestal = true;
bool doData=false;
ROmode romode = serial;
int threshold = 0;
int channel = 20;
double mx_time=50000.;
double pulse=2.;
char *xmlFile=0;
const char *oFile=0;
int NumberOfEvents=-1;

void Run(Rmanager *run_manager) {
   DAQpp::GTimer timer;
   DAQpp::DAQmanager *daq_manager 
      = DAQpp::DAQmanager::theDAQmanager();


   std::cout << "#### S t a r t i n g    r u n  ##### "
	     << std::endl;

   daq_manager->StartRun(true);
   timer.start();
   while ( DoRun && timer()<mx_time ) {
      usleep(1000);
      if ( timer()>mx_time )
	 daq_manager->StopRun();

      if ( run_manager->GetStatus().get_status() !=  DAQpp::RunState::Running )
	 break;

      std::cout << '\r' 
		<< std::setiosflags(std::ios::fixed |
				    std::ios::right
		   )	
		<< std::setw(10)
		<< run_manager->GetStatus().Ntrig() 
		<< " DAQ time " 
		<< std::setw(8) << std::setprecision(3)
		<< run_manager->GetStatus().time()
		<< " rate " 
		<< std::setw(10) << std::setprecision(3)
		<< run_manager->GetStatus().rate()/1000. 
		<< " kHz"
		<< " eff " 
		<< std::setw(7) << std::setprecision(3)
		<< run_manager->GetStatus().eff()
		<< std::flush;
      if ( run_manager->get_logger() ) {
	 DAQpp::FileIOManager *ll = run_manager->get_logger();
	 std::cout << " f " << std::setw(2) << ll->file_number()
		   << " [ " << std::setw(6) << std::setprecision(1)
		   << 100.*ll->relative_size() << "%]"
		   << std::flush;
      }
   }      

   std::cout << std::endl;
   if ( daq_manager->isRunning() )
      daq_manager->StopRun();

   //usleep(1000);
   daq_manager->WaitForEndOfRun();
   std::cout << std::endl << std::flush;      
   std::cout << "#### D o n e  #####"
	     << std::endl;
}

int main(int argc, char **argv) {
   ScanVar var(ScanVar::pulse,0,4,1.);
   // Get parameters from the command line
   if ( parse_cmd_line(argc,argv) )
      return 1;

   if ( !xmlFile ) {
      std::cout << "I need a configuration file" << std::endl;
      return 1;
   }

   // catch control-c
   signal(SIGINT,quit);


   
   // load configuration file and create the modules
   ConfigParser *cfg = ConfigParser::theConfig();
   cfg->reset();

   if (!cfg->parse(xmlFile))
      return 1;



//---------------------------------------------------------------------
// Pointer to  DAQ manager
//---------------------------------------------------------------------   
   DAQpp::DAQmanager *daq_manager 
      = DAQpp::DAQmanager::theDAQmanager();

//---------------------------------------------------------------------
// Saving data. First we run a pedestal run
//---------------------------------------------------------------------   
   if ( oFile || doPedestal ) {
      // Pedestal run
      std::cout << "#### S t a r t i n g    P E D E S T A L    r u n  ##### "
		<< std::endl;
      PedestalRunManager *Rped = new PedestalRunManager("Rped");
      Rped->set_MxEvts(10000);
      
      DAQpp::ModulesMap::const_iterator mm;
      
      for (mm=daq_manager->ModuleMap().begin();
	   mm!=daq_manager->ModuleMap().end();++mm) {
	 DAQpp::Module *md = mm->second ;
	 ModuleParser  *mp = dynamic_cast<ModuleParser *>(
	    cfg->get_id_handler(md->get_id()));
	 mp->save_config(md->get_id());
	 Rped->addModule( md );
      }
      
      std::cout << "Starting Pedestal Run" << std::endl;
      Rped->PrepareForRun();
      Rped->Start();
      if (!Rped->isActive() )
	 Rped->Activate();
      Run(Rped);
      
      // Restore previous settings
      int i;
      for (i=0,mm=daq_manager->ModuleMap().begin();
	   mm!=daq_manager->ModuleMap().end();++mm,i++) {
	 GenModule *md = dynamic_cast<GenModule *>(mm->second);
	 ModuleParser *mp = dynamic_cast<ModuleParser *>(
	    cfg->get_id_handler(md->get_id()));
	 mp->parse_node(md->get_id());
	 md->update_pedestals();
      }
      delete Rped;
      std::cout << "#### D o n e   P E D E S T A L #####"
		<< std::endl;
   }

   Rmanager *run_manager = Rmanager::new_manager(sRunManager,sRunManager);
   
   if ( RunType == PULSE ) {
      PulseRunManager *pr = dynamic_cast<PulseRunManager *>(run_manager);
      pr->set_pulse(pulse);
//      pr->set_rout( romode | MyModule::On );
      pr->set_channel(channel);
   }    
   run_manager->set_monitor(0);
   
   // Add all the modules
   DAQpp::ModulesMap::const_iterator mm;
   for (mm=daq_manager->ModuleMap().begin();
	mm!=daq_manager->ModuleMap().end();++mm) {
      run_manager->addModule( mm->second );
   }   
   
   run_manager->Activate();   
   run_manager->set_MxEvts(NumberOfEvents);   
   if ( oFile )
      run_manager->log_data(oFile,true,50000000);
    

   // Run
   Run(run_manager);
 
   std::cout << "Done" << std::endl;
}


void prthelp(const char *prgnam, struct option *opt) {
   int i;
   printf("Usage: %s [options]\nPosible options:\n",prgnam);
   for (i=0; opt[i].name; i++)
      printf("\t--%s , -%c\n",opt[i].name,opt[i].val);
}

int parse_cmd_line(int argc, char **argv) {
   int option_index;
   RMtype iRunType=PEDESTAL;
   int iped;
   int iRO;
   static struct option long_options[] = {
      {"nevt"      ,1,0,'n'},
      {"time"      ,1,0,'t'},
      {"pulse"     ,1,0,'p'},
      {"threshold" ,1,0,'u'},
      {"channel"   ,1,0,'c'},
      {"pedestal"  ,0,(int *)&iRunType,PEDESTAL},
      {"pulse"     ,0,(int *)&iRunType,PULSE},
      {"data"      ,0,(int *)&iRunType,DATA},
      {"internal"  ,0,(int *)&iRunType,INT_TRG},
      {"out"       ,1,0,'o'},
      {"serial"    ,0,&iRO,0},
      {"sparse"    ,0,&iRO,1},
      {"adjacent"  ,0,&iRO,2},
      {"dopedestal",0,&iped,1},
      {"help"      ,0,0,'h'},
      {0,0,0,0}
   };
   char *prgnam = ( (prgnam=strrchr(argv[0],'/')) ? prgnam+1 : argv[0]);

   while ( 1 ) {
      char c;
      option_index = 0;
      c = getopt_long (argc, argv, ":t:p:u:c:n:h",long_options, &option_index);
      if ( c==-1 ) break;
      switch (c) {
         case 0: 
	 case 1: 
	    break;
         case 'h' :
            prthelp(prgnam,long_options);
            return 1;
	 case 't':
	    mx_time = atof(optarg);
	    break;
	 case 'p':
	    pulse = atof(optarg);
	    break;
	 case 'u':
	    threshold = atoi(optarg);
	    break;
	 case 'c':
	    channel = atoi(optarg);
	    break;
	 case 'n':
	    NumberOfEvents = atoi(optarg);
	    break;
	 case 'o':
	    oFile = optarg;
	    break;
         case ':':
            printf("Option -%c needs a parameter1\n",optopt);
            return 1;
            break;
         case '?':
            printf("Invalid (%d) -%c %s [Ughhhh !!!!]\n",c,optopt,argv[optind]);
            return 1;
	 default:
	    break;
      }
   }

   RunType = iRunType;
   sRunManager = Rnames[RunType];
   doPedestal = (iped!=0);
   
   if ( optind<argc )
      xmlFile = argv[optind++];
   
   switch (iRO) {
      case 0:
	 romode=serial;
	 break;
      case 1:
	 romode=sparse;
	 break;
      case 2:
	 romode=sparse_adj;
	 break;
   }
   return 0;
}