DAQ++ git-vmedaq

#include <iostream>
#include <iomanip>
#include <csignal>
#include <cstdio>
#include <cstring>
#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,
    SCAN,
    LAST
} RMtype;

RMtype RunType;
const char *Rnames[] =
    {
        "data",
        "pedestal",
        "int_trg",
        "pulse",
        "scan",
        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().n_trigger()
            << " 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_max_events(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_id(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_id(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_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_max_events(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 = 0;
    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;
}