//_HADES_CLASS_DESCRIPTION
////////////////////////////////////////////////////////////////
//
//  HBeamTime:
//
//  Helper class to deal with different beamtime settings
//  of the dst
////////////////////////////////////////////////////////////////

#include "hbeamtime.h"
#include "htime.h"
#include "hades.h"
#include "hrecevent.h"
#include "heventheader.h"
#include "hdatasource.h"


ClassImp(HBeamPar)
ClassImp(HBeamTime)

HBeamTime::HBeamTime()
{
 ;
}

Bool_t HBeamTime::getRunID(Int_t& runID,Bool_t print)
{
    // get runID from DataSource, real data from current run id, sim data
    // from reference id in case data source is HRootSource

    runID =-1;
    if(!gHades) {
	if(print) cout<<"Warning:: HBeamTime::getRunID() : Your are running without Hades object. No checks will be done"<<endl;
	return kFALSE;
    }

    if(gHades->getDataSource()) {

	Int_t refID = gHades->getDataSource()->getCurrentRefId();
	if(refID > 0 && refID < 100000 )  //  refID  set  (used for simulations)
	{
	    runID = refID;
	    return kTRUE;
	} else { // real data
	    runID = gHades->getDataSource()->getCurrentRunId();
	    return kTRUE;
	}

    } else  {
	if(print) cout<<"Warning:: HBeamTime::getRunID() : Your are running without connected DataSource. No checks will be done"<<endl;
        return kFALSE;
    }
    return kFALSE;
}

Bool_t HBeamTime::getYearFromRunID(Int_t& year,Bool_t print)
{

    //---------------------------------------------------------
    // switch the different beamtime versions
    Int_t month,day,hour,min,sec;
    UInt_t runid = 0;
    year = 4000;

    if(gHades->getDataSource()) {


	runid       = gHades->getDataSource()->getCurrentRunId();
	Int_t refid = gHades->getDataSource()->getCurrentRefId();

	if( refid > 0 && refid < 100000) {   // reference ID was set and is simulation

	    //----------------------------------------------------------------------------------
	    //apr12sim 2012 12000 12001
	    //ecal13sim 12500 12501 12502
	    //jul14sim 14000 14001 14002 14003
	    //aug14sim 14100 14103
	    //fwdet16sim 14500 14501 14502 14503
	    //prop17sim 15000 15001 15002
	    //mar19sim  16000 16001 16002
	    //feb22sim  17000 17001
            //feb24sim  18000 18001 18100 18101 18102

	    if(refid != -1 )  //  refID  set  (used for simulations)
	    {
		if(refid > 11000 && refid < 25000){  // its a simulation


		    if     (refid >= 12000 && refid <= 12001) year = 2012;       // apr12
		    else if(refid >= 12500 && refid <= 12502) year = 2013;       // ecal13sim
		    else if(refid >= 14000 && refid <= 14003) year = 2014;       // jul14sim
		    else if(refid >= 14100 && refid <= 14103) year = 2014;       // aug14sim
		    else if(refid >= 14500 && refid <= 14503) year = 2016;       // fwdet16sim
		    else if(refid >= 15000 && refid <= 15002) year = 2017;       // prop17sim
		    else if(refid >= 16000 && refid <= 16002) year = 2019;       // mar19sim
		    else if(refid >= 17000 && refid <= 17001) year = 2022;       // feb22sim
		    else if(refid >= 18000 && refid <= 18110) year = 2024;       // feb24sim
		    else {

			if(print) cout<<"Info:: HBeamTime::getYearFromRunID() : Your HRootSource with an unknown RefID = "<<refid<<". Year will be set to 4000."<<endl;
			year = 4000;
		    }

		    return year;
		}
	    }
	    //----------------------------------------------------------------------------------

	    HTime::runIdToBrokenTime(runid,year,month,day,hour,min,sec);
	    return kTRUE;

	} else {
             runid       = gHades->getDataSource()->getCurrentRunId();
	     HTime::runIdToBrokenTime(runid,year,month,day,hour,min,sec);
             return kTRUE;
	}

    } else  {
	if(print) cout<<"Warning:: HBeamTime::getYearFromRunID() : Your are running without connected DataSource. No checks will be done"<<endl;
        return kFALSE;
    }
}

Bool_t HBeamTime::checkBeamTimeSettingByRunId(TString from,Bool_t doNotAllowUnknowBeam,Bool_t print)
{
    // Retrieves the RunId from the DataSource (Unpackers needs to be running!)
    // and check if the time from the runID fits
    // the setting in gHades->setBeamTimeID() (constants
    // defined in hbeamtime.h HADES::eBeamTime)
    // String from should be set to class::function (like HParticleCandFiller::init())
    // to identify the caller.
    // doNotAllowUnknowBeam = kTRUE will reject HADES::kUnknownBeam
    // print = kTRUE will print beam time infos in case of error

    if(!gHades) {
	cout<<"Error:: HBeamTime::checkBeamTimeSettingByRunId() : No HADES object found!"<<endl;
        exit(1);
    }
    HRecEvent* evt = (HRecEvent*)gHades->getCurrentEvent();
    if(!evt) {
        cout<<"Error:: HBeamTime::checkBeamTimeSettingByRunId() : No Event object found!"<<endl;
        exit(1);
    }

    //---------------------------------------------------------
    // switch the different beamtime versions
    Int_t year;
    UInt_t runid = 0;

    if(!getYearFromRunID(year,print)) return kFALSE;

    Int_t beamtime = gHades->getBeamTimeID();

    if(!checkBeamTimeID(beamtime,from,doNotAllowUnknowBeam,print)) {
        return kFALSE;
    }
    //---------------------------------------------------------

    Int_t beamyear = mIdToYear[beamtime];

    if(year > beamyear){
	if(print)  cout<<"Warning:: HBeamTime::checkBeamTimeSettingByRunId() : Your are running Hades with configuration for HADES::"<<mIdToName[beamtime].Data()<<", but the hld file is older ("<<year<<", runID "<<runid<<")! Just a reminder."<<endl;
	return kFALSE;
    }
    if(year < beamyear){
	if(print)  cout<<"Warning:: HBeamTime::checkBeamTimeSettingByRunId() : Your are running Hades with configuration for HADES::"<<mIdToName[beamtime].Data()<<", but the hld file is newer ("<<year<<", runID "<<runid<<")! Just a reminder."<<endl;
	return kFALSE;
    }

    return kTRUE;
}


Bool_t HBeamTime::checkBeamTimeID(Int_t id,TString from,Bool_t doNotAllowUnknowBeam,Bool_t print)
{
    // check if the provided ID is known.
    // returns kTRUE if known, else kFALSE
    // String from should be set to class::function (like HParticleCandFiller::init())
    // to identify the caller.
    // doNotAllowUnknowBeam = kTRUE will reject HADES::kUnknownBeam
    // print = kTRUE will print beam time infos in case of error

    if(doNotAllowUnknowBeam && id == HADES::kUnknownBeam) {
	if(print) {
	    TString msg = " Called from : ";
	    if(from != ""){ msg += from; }
	    else { msg = ""; }
	    cout<<"Error:: HBeamTime::checkBeamTimeID() : beam ID = HADES::kUnknownBeam not allowd here ! ("<<msg.Data()<<" )"<<endl;
	    cout<<"                                       use gHades ->setBeamTimeID(Int_t id) to set it properly ! "<<endl;
	    printBeamTimeInfo(-1);
	}
	return kFALSE;
    }

    map<Int_t,TString>::iterator it = mIdToName.find(id);
    if(it == mIdToName.end()){
	if(print){
	    TString msg = " Called from : ";
	    if(from != ""){ msg += from; }
	    else { msg = ""; }
	    cout<<"Error:: HBeamTime::checkBeamTimeID() : beam ID = "<<id<<" not known!"<<msg.Data()<<endl;
	    cout<<"                                       use gHades ->setBeamTimeID(Int_t id) to set it properly ! "<<endl;
	    printBeamTimeInfo(-1);
	}
	return kFALSE;
    } else {
	return kTRUE;
    }
}

Bool_t HBeamTime::printBeamTimeInfo(Int_t id,TString from)
{
    // prints the name of ID + year + time range
    // if id <0, all IDS will be printed (return kTRUE)
    // if the id is not known kFALSE will returned
    // and the list of known IDs will be printed
    // String from should be set to class::function (like HParticleCandFiller::init())
    // to identify the caller.

    if(id < 0) {
	// print all known beam IDs
        cout<<"--------------------------------------------------------------"<<endl;
	cout<<"Known HADES beam IDs :"<<endl;
	for(UInt_t i = 0; i < mIdToName.size(); i ++ ){
	    cout<<"HADES::"<<setw(14)<<mIdToName[i]<<" , year: "<<mIdToYear[i]<<", time range : "<<mIdToRange[i]<<endl;
	}
        cout<<"--------------------------------------------------------------"<<endl;
        return kTRUE;
    }

    if(!checkBeamTimeID(id,from)){
	return kFALSE;
    }

    cout<<"--------------------------------------------------------------"<<endl;
    cout<<"HADES::"<<mIdToName[id]<<" ID = "<<id<<" , year: "<<mIdToYear[id]<<", time range : "<<mIdToRange[id]<<endl;
    cout<<"--------------------------------------------------------------"<<endl;

    return kTRUE;
}

void HBeamTime::printBeamPar()
{
    cout<<"--------------------------------------------------------------------------------------------------------------"<<endl;
    cout<<"REAL DATA BEAM PAR:"<<endl;
    printBeamParReal();
    cout<<"--------------------------------------------------------------------------------------------------------------"<<endl;
    cout<<"SIM  DATA BEAM PAR:"<<endl;
    printBeamParSim();
    cout<<"--------------------------------------------------------------------------------------------------------------"<<endl;
}

void HBeamTime::printBeamParReal()
{

    for(UInt_t i = 0; i < vBeamPar.size(); i++){
	HBeamPar& p = vBeamPar[i];
        TString date1 = HTime::runIdToTimeString(p.firstRunID,1,kFALSE);
        TString date2 = HTime::runIdToTimeString(p.lastRunID ,1,kFALSE);
	printf("%15s, BeamEnergy : %5.0f [Mev/u], fieldFactor : %6.4f, first file : %s, firstRunID : %15i (%s), last file : %s, lastRunID : %15i (%s), system : %s\n",
	       HBeamTime::getBeamTimeName(p.beamID).Data(),
	       p.beamEnergy, p.fieldFactor,
	       p.firstFile.Data(),p.firstRunID,date1.Data(),
	       p.lastFile.Data() ,p.lastRunID,date2.Data() ,
	       p.collisionSystem.Data());
    }

    return;
}

void HBeamTime::printBeamParSim()
{

    for(UInt_t i = 0; i < vBeamParSim.size(); i++){
	HBeamPar& p = vBeamParSim[i];
	printf("%15s, BeamEnergy : %5.0f [Mev/u], fieldFactor : %6.4f, firstRunID : %15i, lastRunID : %15i, system : %s\n",
	       HBeamTime::getBeamTimeName(p.beamID).Data(),
	       p.beamEnergy, p.fieldFactor,
	       p.firstRunID,p.lastRunID,
	       p.collisionSystem.Data());
    }

    return;
}

time_t HBeamTime::dateToTime(TString date)
{
    // converts the beam ime date string  "dd-mm-yyyy hh:mm:ss"
    // (GSI +1 time zone and dst on/off) to UTC time_t to
    // be independend on time zone and dst. Use
    // time_t start
    // struct tm* st1  = gmtime(&start) to convert to broken down
    // time and print asctime(st1).
    // 	st1->tm_year  = y  // only years since  1900
    //  st1->tm_mon   = mo // counting from 0   0-11
    //  st1->tm_mday  = d; // counting from 1   1-31
    //  st1->tm_hour  = h; //                   0-23
    //  st1->tm_min   = m; //                   0-59
    //  st1->tm_sec   = s; //                   0-59 (leap 60)



    //         dd-mm-yyyy hh:mm:ss
    // format "01-01-4000 00:00:00"
    //                          19

    TString ds  = TString(date( 0,2));
    TString mos = TString(date( 3,2));
    TString ys  = TString(date( 6,4));
    TString hs  = TString(date(11,2));
    TString ms  = TString(date(14,2));
    TString ss  = TString(date(17,2));

    Int_t d  = ds.Atoi();
    Int_t mo = mos.Atoi();
    Int_t y  = ys.Atoi();
    Int_t h  = hs.Atoi();
    Int_t m  = ms.Atoi();
    Int_t s  = ss.Atoi();

    struct tm t;
    time_t time_of_day;
    time_t gtime_of_day;

    t.tm_year  = y - 1900;// only years since  1900
    t.tm_mon   = mo - 1;  // counting from 0   0-11
    t.tm_mday  = d;       // counting from 1   1-31
    t.tm_hour  = h;       //                   0-23
    t.tm_min   = m;       //                   0-59
    t.tm_sec   = s;       //                   0-59 (leap 60)
    t.tm_isdst = 0;       //                   1=daylight saving time active  , 0 =not active, -1 not available find out from local timezone
 
    time_of_day  = timegm(&t); // input local time GSI (timezone +1), timegm will not change timezones (as designed for UTC input)
    gtime_of_day = time_of_day - 3600;  // gmtime :  +1 (at GSI) timezone substracted

    struct tm* t2 = gmtime(&gtime_of_day);  // we need to compare to findout if DST was used

    if(t2->tm_hour+1 == h) { // we have to use summer time ( + summer shift)

	t.tm_year  = y - 1900; // only years since  1900
	t.tm_mon   = mo - 1;   // counting from 0   0-11
	t.tm_mday  = d;        // counting from 1   1-31
	t.tm_hour  = h;        //                   0-23
	t.tm_min   = m;        //                   0-59
	t.tm_sec   = s;        //                   0-59 (leap 60)
	t.tm_isdst = 1;
	time_of_day = timegm(&t); // now substract summer shift
    }

    return time_of_day;
}

Bool_t HBeamTime::getBeamTimeRange(Int_t id, time_t& start,time_t& end)
{
    // returns the time_t for start and end of a given beamtime
    // (date original is local time GSI (time zone +1), daylight saving
    // time (summer/winter time)) converted to UTC to
    // be independend on time zone and dst. Use
    // struct tm* st1  = gmtime(&start) to convert to broken down
    // time and print asctime(st1).
    // 	st1->tm_year  = y  // only years since  1900
    //  st1->tm_mon   = mo // counting from 0   0-11
    //  st1->tm_mday  = d; // counting from 1   1-31
    //  st1->tm_hour  = h; //                   0-23
    //  st1->tm_min   = m; //                   0-59
    //  st1->tm_sec   = s; //                   0-59 (leap 60)


    if(!checkBeamTimeID(id)){
	start = 0;
        end   = 0;
	return kFALSE;
    }
    //         dd-mm-yyyy hh:mm:ss#dd-mm-yyyy hh:mm:ss
    // format "01-01-4000 00:00:00#01-01-4000 23:59:59"
    //                          19
    TString range = mIdToRange[id];
    TString st = TString(range( 0,19));
    TString en = TString(range(20,19));

    start = dateToTime(st);
    end   = dateToTime(en);

    return kTRUE;

}

TString HBeamTime::getBeamTimeName(Int_t id)
{
    // returns the name of a beam ID like kApr12 for HADES::kApr12

    TString name;
    if(!checkBeamTimeID(id,"",kFALSE)){ return name;}

    map<Int_t,TString>::iterator it = mIdToName.find(id);
    if(it != mIdToName.end()){
        name = it ->second;
    }

    return name;
}

Bool_t HBeamTime::getBeamPar(Int_t runId,HBeamPar& par)
{
    if(runId < 100000) return getBeamParSim (runId,par);
    else               return getBeamParReal(runId,par);
}

Bool_t HBeamTime::getBeamParReal(Int_t runId,HBeamPar& par)
{
    par.reset();

    Int_t setBeamID = 0 ;
    if(gHades) setBeamID = gHades->getBeamTimeID();



    UInt_t n = vBeamPar.size();
    for(UInt_t i = 0; i < n; i++){
	HBeamPar& p = vBeamPar[i];
	if(runId >= p.firstRunID && runId <= p.lastRunID ){
	    par   = p;
	    if(par.beamID != setBeamID){
               ::Warning("getBeamPar()","Current BEAM ID = %d does not match BEAM ID from BeamPar = %d (runID = %d). Please check your settings!", setBeamID,par.beamID,runId);
	    }

	    return kTRUE;
	}
    }

    if(runId < vBeamPar[0].firstRunID) {
	par = vBeamPar[0];
	::Warning("getBeamPar()","Current RunID = %d is before first BeamPar in Table. Select first Par!",runId);
	if(par.beamID != setBeamID){
	    ::Warning("getBeamPar()","Current BEAM ID = %d does not match BEAM ID from BeamPar = %d (runID = %d).. Please check your settings!", setBeamID,par.beamID,runId);
	}
	par.print();
	printBeamPar();
	return kFALSE;
    }
    if(runId > vBeamPar[n-1].lastRunID) {
	par = vBeamPar[n-1];
	::Warning("getBeamPar()","Current RunID = %d is past last BeamPar in Table. Select last Par!",runId);
	if(par.beamID != setBeamID){
	    ::Warning("getBeamPar()","Current BEAM ID = %d does not match BEAM ID from BeamPar = %d (runID = %d).. Please check your settings!", setBeamID,par.beamID,runId);
	}
        par.print();
	printBeamPar();
	return kFALSE;
    }

    for(UInt_t i = 1; i < vBeamPar.size(); i++){
	HBeamPar& p2 = vBeamPar[i];
	HBeamPar& p1 = vBeamPar[i-1];

	if(runId > p1.lastRunID && runId < p2.firstRunID){

	    if(abs(runId-p1.lastRunID) < abs(runId-p2.firstRunID))
	    {
		par = p1;
		::Warning("getBeamPar()","Current RunID = %d is between BeamPar in Table. Select former Par!",runId);
		if(par.beamID != setBeamID){
		    ::Warning("getBeamPar()","Current BEAM ID = %d does not match BEAM ID from BeamPar = %d (runID = %d). Please check your settings!", setBeamID,par.beamID,runId);
		}
		par.print();
		printBeamPar();
		return kFALSE;
	    } else {
		par = p2;
		::Warning("getBeamPar()","Current RunID = %d is between BeamPar in Table. Select later Par!",runId);
		par.print();
		if(par.beamID != setBeamID){
		    ::Warning("getBeamPar()","Current BEAM ID = %d does not match BEAM ID from BeamPar = %d (runID = %d). Please check your settings!", setBeamID,par.beamID,runId);
		}
		printBeamPar();
		return kFALSE;
	    }

	}
    }

    return kFALSE;
}

Bool_t HBeamTime::getBeamParSim(Int_t runId,HBeamPar& par)
{
    par.reset();

    Int_t setBeamID = 0 ;
    if(gHades) setBeamID = gHades->getBeamTimeID();

    UInt_t n = vBeamParSim.size();
    for(UInt_t i = 0; i < n; i++){
	HBeamPar& p = vBeamParSim[i];
	if(runId == p.firstRunID){
	    par   = p;
	    if(par.beamID != setBeamID){
               ::Warning("getBeamParSim()","Current BEAM ID = %d does not match BEAM ID from BeamPar = %d. Please check your settings!", setBeamID,par.beamID);
	    }
            return kTRUE;
	}
    }
    ::Error("getBeamParSim()","Current RunID = %d not found in Table!",runId);
    printBeamParSim();
    return kFALSE;
}

map<Int_t,Int_t> HBeamTime::initBeamTimesYear()
{
    map<Int_t,Int_t> m;

    m[HADES::kUnknownBeam] = 4000;
    m[HADES::kApr12]       = 2012;
    m[HADES::kJul14]       = 2014;
    m[HADES::kAug14]       = 2014;
    m[HADES::kMar19]       = 2019;
    m[HADES::kFeb22]       = 2022;
    m[HADES::kFeb24]       = 2024;
    m[HADES::kApr25]       = 2025;

    return m;
}

map<Int_t,TString> HBeamTime::initBeamTimesNames()
{
    map<Int_t,TString> m;

    m[HADES::kUnknownBeam] = "kUnknownBeam";
    m[HADES::kApr12]       = "kApr12";
    m[HADES::kJul14]       = "kJul14";
    m[HADES::kAug14]       = "kAug14";
    m[HADES::kMar19]       = "kMar19";
    m[HADES::kFeb22]       = "kFeb22";
    m[HADES::kFeb24]       = "kFeb24";
    m[HADES::kApr25]       = "kApr25";

    return m;
}

map<Int_t,TString> HBeamTime::initBeamTimesRange()
{
    map<Int_t,TString> m;

    m[HADES::kUnknownBeam] = "01-01-4000 00:00:00#01-01-4000 23:59:59";
    m[HADES::kApr12]       = "19-03-2012 00:00:00#13-05-2012 23:59:59";
    m[HADES::kJul14]       = "01-06-2014 00:00:00#24-07-2014 23:59:59";
    m[HADES::kAug14]       = "25-07-2014 00:00:00#02-10-2014 23:59:59";
    m[HADES::kMar19]       = "19-01-2019 00:00:00#14-05-2019 23:59:59";
    m[HADES::kFeb22]       = "01-01-2022 00:00:00#30-04-2022 23:59:59";
    m[HADES::kFeb24]       = "01-10-2023 00:00:00#30-04-2024 23:59:59";
    m[HADES::kApr25]       = "22-01-2025 00:00:00#31-05-2025 23:59:59";

    return m;
}

vector<HBeamPar> HBeamTime::initBeamPar()
{
    vector<HBeamPar> v;

    HBeamPar p;
    p.setPar(HADES::kApr12,1230,0.7215,"Au+Au" ,133656363,136366933,"be12096220603","be12128070213");
    v.push_back(p);

    p.setPar(HADES::kJul14,1700,0.7215,"pim+W" ,201783221,205049472,"md14154101341","be14192053112");
    v.push_back(p);
    p.setPar(HADES::kJul14,1700,0.7215,"pim+C" ,205102093,205312140,"be14192200813","be14195062900");
    v.push_back(p);
    p.setPar(HADES::kJul14,700 ,0.7215,"pim+C" ,205365018,205368707,"be14195211018","be14195221147");
    v.push_back(p);
    p.setPar(HADES::kJul14,1700,0.7215,"pim+C" ,205371864,205398963,"be14195230424","be14196063603");
    v.push_back(p);
    p.setPar(HADES::kJul14,1700,0.7215,"pim+PE",205447730,205461529,"be14196200850","be14196235849");
    v.push_back(p);
    p.setPar(HADES::kJul14,700 ,0.7215,"pim+PE",205448553,205573220,"be14196202233","be14198070020");
    v.push_back(p);

    p.setPar(HADES::kAug14,690 ,0.7215,"pim+PE",208536066,209740405,"be14232140106","be14246123325");
    v.push_back(p);
    p.setPar(HADES::kAug14,748 ,0.7215,"pim+PE",209768082,209814825,"be14246201442","be14247091345");
    v.push_back(p);
    p.setPar(HADES::kAug14,656 ,0.7215,"pim+PE",209859538,209959105,"be14247213858","be14249011825");
    v.push_back(p);
    p.setPar(HADES::kAug14,800 ,0.7215,"pim+PE",209959362,209986822,"be14249012242","be14249090022");
    v.push_back(p);
    p.setPar(HADES::kAug14,612 ,0.7215,"pim+C" ,210022678,210087861,"be14249185758","be14250130421");
    v.push_back(p);
    p.setPar(HADES::kAug14,690 ,0.7215,"pim+C" ,210109518,210580897,"be14250190518","be14256060137");
    v.push_back(p);
    p.setPar(HADES::kAug14,800 ,0.7215,"pim+C" ,210159053,210223751,"be14251085053","be14252024911");
    v.push_back(p);
    p.setPar(HADES::kAug14,748 ,0.7215,"pim+C" ,210224730,210255254,"be14252030530","be14252113414");
    v.push_back(p);
    p.setPar(HADES::kAug14,656 ,0.7215,"pim+C" ,210287593,210409080,"be14252203313","be14254061800");
    v.push_back(p);


    p.setPar(HADES::kMar19,1580,0.9235,"Ag+Ag" ,351575439,353853646,"be19062021039","be19088110046");     //353 174061
    v.push_back(p);
    p.setPar(HADES::kMar19,1230,0.7215,"Ag+Ag" ,353857245,353986779,"be19088120045","be19089235939");
    v.push_back(p);
    p.setPar(HADES::kMar19,1230,0.0577,"Ag+Ag" ,354052903,354069561,"be19090192143","be19090235921");
    v.push_back(p);

    p.setPar(HADES::kFeb22,4500,0.9235,"p+p"   ,443848018,446743512,"be22034012658","be22067134512");
    v.push_back(p);
    p.setPar(HADES::kFeb22,1580,0.9235,"p+p"   ,446754494,446828471,"be22067164814","be22068132111");
    v.push_back(p);

    p.setPar(HADES::kFeb24, 800,0.5339,"C+C"   ,507270001,507449496,"be24038024001","be24040043136");
    v.push_back(p);
    p.setPar(HADES::kFeb24, 800,0.0000,"C+C"   ,507451894,507460334,"be24040051134","be24040073214");
    v.push_back(p);

    p.setPar(HADES::kFeb24, 800,0.5339,"Au+Au" ,509243471,509556129,"be24060225111","be24064134209");
    v.push_back(p);
    p.setPar(HADES::kFeb24, 800,0.0000,"Au+Au" ,509556277,509558707,"be24064134437","be24064142507");
    v.push_back(p);
    p.setPar(HADES::kFeb24, 200,0.0000,"Au+Au" ,509764202,510773660,"be24066233002","be24078155420");
    v.push_back(p);

    p.setPar(HADES::kApr25, 800,0.0000,"Au+Au" ,545621121,545638100,"be25116004521","be25116052820");
    v.push_back(p);
    p.setPar(HADES::kApr25, 800,0.5339,"Au+Au" ,545641864,545906415,"be25116063104","be25119080015");
    v.push_back(p);
    p.setPar(HADES::kApr25, 800,0.0577,"Au+Au" ,545913866,545992855,"be25119100426","be25120080055");
    v.push_back(p);
    p.setPar(HADES::kApr25, 600,0.5339,"Au+Au" ,546006318,546169232,"be25120114518","be25122090032");
    v.push_back(p);
    p.setPar(HADES::kApr25, 400,0.5339,"Au+Au" ,546177621,546304748,"be25122112021","be25123223908");
    v.push_back(p);
    p.setPar(HADES::kApr25, 200,0.5339,"Au+Au" ,546320682,546426905,"be25124030442","be25125083505");
    v.push_back(p);

    return v;
}

vector<HBeamPar> HBeamTime::initBeamParSim()
{
    vector<HBeamPar> v;

    HBeamPar p;
    p.setPar(HADES::kApr12,1230,0.7215,"Au+Au" ,12000,12000);
    v.push_back(p);
    p.setPar(HADES::kApr12,1230,0.7215,"Au+Au" ,12001,12001);
    v.push_back(p);
    p.setPar(HADES::kJul14,1700,0.7215,"pim+C" ,14000,14000);
    v.push_back(p);
    p.setPar(HADES::kJul14,1700,0.7215,"pim+Cu",14001,14001);
    v.push_back(p);
    p.setPar(HADES::kJul14,1700,0.7215,"pim+W" ,14002,14002);
    v.push_back(p);
    p.setPar(HADES::kJul14,1700,0.7215,"pim+PE",14003,14003);
    v.push_back(p);
    p.setPar(HADES::kAug14,700 ,0.7215,"pim+C" ,14100,14100);
    v.push_back(p);
    p.setPar(HADES::kAug14,700 ,0.7215,"pim+PE",14103,14103);
    v.push_back(p);
    p.setPar(HADES::kMar19,1580,0.9235,"Ag+Ag" ,16000,16000);
    v.push_back(p);
    p.setPar(HADES::kMar19,1230,0.7215,"Ag+Ag" ,16001,16001);
    v.push_back(p);
    p.setPar(HADES::kMar19,1230,0.0577,"Ag+Ag" ,16002,16002);
    v.push_back(p);
    p.setPar(HADES::kFeb22,4500,0.9235,"p+p"   ,17000,17000);
    v.push_back(p);
    p.setPar(HADES::kFeb22,1580,0.9235,"p+p"   ,17001,17001);
    v.push_back(p);
    p.setPar(HADES::kFeb24,800 ,0.5339,"C+C"   ,18000,18000);
    v.push_back(p);
    p.setPar(HADES::kFeb24,800 ,0.0000,"C+C"   ,18001,18001);
    v.push_back(p);
    p.setPar(HADES::kFeb24,800 ,0.5339,"Au+Au" ,18100,18100);
    v.push_back(p);
    p.setPar(HADES::kFeb24,800 ,0.0000,"Au+Au" ,18101,18101);
    v.push_back(p);
    p.setPar(HADES::kFeb24,200 ,0.0000,"Au+Au" ,18102,18102);
    v.push_back(p);

    return v;
}

map<Int_t,Int_t>   HBeamTime::mIdToYear  = HBeamTime::initBeamTimesYear();
map<Int_t,TString> HBeamTime::mIdToName  = HBeamTime::initBeamTimesNames();
map<Int_t,TString> HBeamTime::mIdToRange = HBeamTime::initBeamTimesRange();
vector<HBeamPar>   HBeamTime::vBeamPar   = HBeamTime::initBeamPar();
vector<HBeamPar>   HBeamTime::vBeamParSim= HBeamTime::initBeamParSim();