void
RPCTarget::RequestDone(FRT_RPCRequest *req)
{
HandlerList handlers;
{
vespalib::MonitorGuard guard(_lock);
assert(_state == TARGET_INVOKED);
if (req->CheckReturnTypes("s")) {
FRT_Values &val = *req->GetReturn();
try {
_version.reset(new vespalib::Version(val[0]._string._str));
} catch (vespalib::IllegalArgumentException &e) {
(void)e;
}
} else if (req->GetErrorCode() == FRTE_RPC_NO_SUCH_METHOD) {
_version.reset(new vespalib::Version("4.1"));
}
_versionHandlers.swap(handlers);
_state = PROCESSING_HANDLERS;
}
for (HandlerList::iterator it = handlers.begin();
it != handlers.end(); ++it)
{
(*it)->handleVersion(_version.get());
}
{
vespalib::MonitorGuard guard(_lock);
_state = (_version.get() ? VERSION_RESOLVED : VERSION_NOT_RESOLVED);
guard.broadcast();
}
req->SubRef();
}
/*! Calls low resource handlers for the given resources.
sLowResourceLock must be held.
*/
static void
call_handlers(uint32 lowResources)
{
if (sLowResourceHandlers.IsEmpty())
return;
// Add a marker, so we can drop the lock while calling the handlers and
// still iterate safely.
low_resource_handler marker;
sLowResourceHandlers.Insert(&marker, false);
while (low_resource_handler* handler
= sLowResourceHandlers.GetNext(&marker)) {
// swap with handler
sLowResourceHandlers.Swap(&marker, handler);
marker.priority = handler->priority;
int32 resources = handler->resources & lowResources;
if (resources != 0) {
recursive_lock_unlock(&sLowResourceLock);
handler->function(handler->data, resources,
low_resource_state_no_update(resources));
recursive_lock_lock(&sLowResourceLock);
}
}
// remove marker
sLowResourceHandlers.Remove(&marker);
}
HandlerList NormalizedGradientUInt8_GetAVXHandlers()
{
HandlerList lstHandlers;
lstHandlers.push_back( NormalizedGradientUInt8Handler::Create< NormalizedGradientUInt8Handler_AVX >() );
return std::move( lstHandlers );
}
HandlerList ConvolutionFloat_GetAVXHandlers()
{
HandlerList lstHandlers;
lstHandlers.push_back( ConvolutionFloatHandler::Create< ConvolutionFloatHandler_AVX >() );
return std::move( lstHandlers );
}
HandlerList TopologicalErosionFloat_GetAVXHandlers()
{
HandlerList lstHandlers;
lstHandlers.push_back( TopologicalErosionFloatHandler::Create< TopologicalErosionFloatHandler_AVX >() );
return std::move( lstHandlers );
}
HandlerList MinMaxDetectorFloat_GetAVXHandlers()
{
HandlerList lstHandlers;
lstHandlers.push_back( MinMaxDetectorFloatHandler::Create< MinMaxDetectorFloatHandler_AVX >() );
return std::move( lstHandlers );
}
HandlerList ImageAddFloat_GetAVXHandlers()
{
HandlerList lstHandlers;
lstHandlers.push_back( ImageAddFloatHandler::Create< ImageAddFloatHandler_AVXRef >() );
lstHandlers.push_back( ImageAddFloatHandler::Create< ImageAddFloatHandler_AVX >() );
return std::move( lstHandlers );
}
void EraseHandler(HandlerList& l,SignalHandler* h)
{
list<SignalHandler*>::iterator i,p;
for(i=l.begin();i!=l.end();i++) {
if(*i==h) {
p=i; p--;
l.erase(i);
i=p;
}
}
}
HandlerList ConvolutionUInt8_GetSSEHandlers()
{
HandlerList lstHandlers;
lstHandlers.push_back( ConvolutionUInt8Handler::Create< ConvolutionUInt8Handler_SSE2 >() );
lstHandlers.push_back( ConvolutionUInt8Handler::Create< ConvolutionUInt8Handler_SSE3 >() );
lstHandlers.push_back( ConvolutionUInt8Handler::Create< ConvolutionUInt8Handler_SSSE3 >() );
lstHandlers.push_back( ConvolutionUInt8Handler::Create< ConvolutionUInt8Handler_SSE4_1 >() );
lstHandlers.push_back( ConvolutionUInt8Handler::Create< ConvolutionUInt8Handler_SSE4_2 >() );
return std::move( lstHandlers );
}
HandlerList TopologicalErosionFloat_GetSSEHandlers()
{
HandlerList lstHandlers;
lstHandlers.push_back( TopologicalErosionFloatHandler::Create< TopologicalErosionFloatHandler_SSE2 >() );
lstHandlers.push_back( TopologicalErosionFloatHandler::Create< TopologicalErosionFloatHandler_SSE3 >() );
lstHandlers.push_back( TopologicalErosionFloatHandler::Create< TopologicalErosionFloatHandler_SSSE3 >() );
lstHandlers.push_back( TopologicalErosionFloatHandler::Create< TopologicalErosionFloatHandler_SSE4_1 >() );
lstHandlers.push_back( TopologicalErosionFloatHandler::Create< TopologicalErosionFloatHandler_SSE4_2 >() );
return std::move( lstHandlers );
}
HandlerList BubbleSortMedianOptimizedFloat_GetSSEHandlers()
{
HandlerList lstHandlers;
lstHandlers.push_back( BubbleSortMedianOptimizedFloatHandler::Create< BubbleSortMedianOptimizedFloatHandler_SSE2 >() );
lstHandlers.push_back( BubbleSortMedianOptimizedFloatHandler::Create< BubbleSortMedianOptimizedFloatHandler_SSE3 >() );
lstHandlers.push_back( BubbleSortMedianOptimizedFloatHandler::Create< BubbleSortMedianOptimizedFloatHandler_SSSE3 >() );
lstHandlers.push_back( BubbleSortMedianOptimizedFloatHandler::Create< BubbleSortMedianOptimizedFloatHandler_SSE4_1 >() );
lstHandlers.push_back( BubbleSortMedianOptimizedFloatHandler::Create< BubbleSortMedianOptimizedFloatHandler_SSE4_2 >() );
return std::move( lstHandlers );
}
void PluginManager::callEvent(Event &event)
{
HandlerList *handlers = event.getHandlers();
std::vector<RegisteredListener *> listeners = handlers->getRegisteredListeners();
for (RegisteredListener *registration : listeners)
{
if (!registration->getPlugin()->isEnabled())
continue;
registration->callEvent(event);
}
}
HandlerList ImageAddFloat_GetSSEHandlers()
{
HandlerList lstHandlers;
lstHandlers.push_back( ImageAddFloatHandler::Create< ImageAddFloatHandler_SSERef >() );
lstHandlers.push_back( ImageAddFloatHandler::Create< ImageAddFloatHandler_SSE >() );
lstHandlers.push_back( ImageAddFloatHandler::Create< ImageAddFloatHandler_SSE2 >() );
lstHandlers.push_back( ImageAddFloatHandler::Create< ImageAddFloatHandler_SSE3 >() );
lstHandlers.push_back( ImageAddFloatHandler::Create< ImageAddFloatHandler_SSSE3 >() );
lstHandlers.push_back( ImageAddFloatHandler::Create< ImageAddFloatHandler_SSE4_1 >() );
lstHandlers.push_back( ImageAddFloatHandler::Create< ImageAddFloatHandler_SSE4_2 >() );
return std::move( lstHandlers );
}
void PluginManager::registerEvent(EventType type, Listener *listener, std::function<void(Listener *, Event &)> func, Plugin *plugin, EventPriority priority, bool ignoreCancelled)
{
if(!plugin->isEnabled())
return;
auto executor = [func](Listener *listener, Event &event)
{
func(listener, event);
};
HandlerList *handlerList = getEventListeners(type);
if(handlerList)
handlerList->registerListener(new RegisteredListener(listener, executor, priority, plugin, ignoreCancelled));
}
static int
dump_handlers(int argc, char** argv)
{
kprintf("current state: %c%c%c%c\n",
(sLowResources & B_KERNEL_RESOURCE_PAGES) != 0 ? 'p' : '-',
(sLowResources & B_KERNEL_RESOURCE_MEMORY) != 0 ? 'm' : '-',
(sLowResources & B_KERNEL_RESOURCE_SEMAPHORES) != 0 ? 's' : '-',
(sLowResources & B_KERNEL_RESOURCE_ADDRESS_SPACE) != 0 ? 'a' : '-');
kprintf(" pages: %s\n", state_to_string(sLowPagesState));
kprintf(" memory: %s\n", state_to_string(sLowMemoryState));
kprintf(" sems: %s\n", state_to_string(sLowSemaphoresState));
kprintf(" aspace: %s\n\n", state_to_string(sLowSpaceState));
HandlerList::Iterator iterator = sLowResourceHandlers.GetIterator();
kprintf("function data resources prio function-name\n");
while (iterator.HasNext()) {
low_resource_handler *handler = iterator.Next();
const char* symbol = NULL;
elf_debug_lookup_symbol_address((addr_t)handler->function, NULL,
&symbol, NULL, NULL);
char resources[16];
snprintf(resources, sizeof(resources), "%c %c %c",
handler->resources & B_KERNEL_RESOURCE_PAGES ? 'p' : ' ',
handler->resources & B_KERNEL_RESOURCE_MEMORY ? 'm' : ' ',
handler->resources & B_KERNEL_RESOURCE_SEMAPHORES ? 's' : ' ');
kprintf("%p %p %s %4ld %s\n", handler->function, handler->data,
resources, handler->priority, symbol);
}
return 0;
}
// Compare Handler lists
int HandlerList::compare(const HandlerList& l) const
{
// Compare this
if (this == &l)
return 0;
// Compare number of types
int c = ::compare(nTypes(), l.nTypes());
if (c)
return c;
// Compare individual lists
for (unsigned t = 0; t < nTypes(); t++)
{
HandlerRec *r1 = handlers[t];
HandlerRec *r2 = l.handlers[t];
while (r1 != 0 && r2 != 0)
{
c = compare(*r1, *r2);
if (c)
return c;
r1 = r1->next;
r2 = r2->next;
}
// If one of the lists is longer, it is also the greater one
c = ::compare((void *)r1, (void *)r2);
if (c)
return c;
}
return 0;
}
status_t
unregister_low_resource_handler(low_resource_func function, void* data)
{
TRACE(("unregister_low_resource_handler(function = %p, data = %p)\n",
function, data));
RecursiveLocker locker(&sLowResourceLock);
HandlerList::Iterator iterator = sLowResourceHandlers.GetIterator();
while (iterator.HasNext()) {
low_resource_handler* handler = iterator.Next();
if (handler->function == function && handler->data == data) {
sLowResourceHandlers.Remove(handler);
free(handler);
return B_OK;
}
}
return B_ENTRY_NOT_FOUND;
}
void
SignalHandler::handle_signal(
int signal)
{
typedef std::vector<const HandlerMap::value_type *> HandlerList;
time_t now = ::time(NULL);
std::cerr << "Sierra received signal " << signal << " at " << ::ctime(&now) << std::endl;
HandlerList handlers;
std::pair<HandlerMap::const_iterator, HandlerMap::const_iterator> range = m_handlerMap.equal_range(signal);
for (HandlerMap::const_iterator pos = range.first; pos != range.second; ++pos)
handlers.push_back(&*pos);
for (HandlerList::const_iterator it = handlers.begin(); it != handlers.end(); ++it) {
CallbackBase &obj = *(*it)->second;
obj();
}
}
/*! Registers a low resource handler. The higher the \a priority, the earlier
the handler will be called in low resource situations.
*/
status_t
register_low_resource_handler(low_resource_func function, void* data,
uint32 resources, int32 priority)
{
TRACE(("register_low_resource_handler(function = %p, data = %p)\n",
function, data));
low_resource_handler *newHandler = (low_resource_handler*)malloc(
sizeof(low_resource_handler));
if (newHandler == NULL)
return B_NO_MEMORY;
newHandler->function = function;
newHandler->data = data;
newHandler->resources = resources;
newHandler->priority = priority;
RecursiveLocker locker(&sLowResourceLock);
// sort it in after priority (higher priority comes first)
HandlerList::ReverseIterator iterator
= sLowResourceHandlers.GetReverseIterator();
low_resource_handler* last = NULL;
while (iterator.HasNext()) {
low_resource_handler *handler = iterator.Next();
if (handler->priority >= priority) {
sLowResourceHandlers.Insert(last, newHandler);
return B_OK;
}
last = handler;
}
sLowResourceHandlers.Add(newHandler, false);
return B_OK;
}
int main(int argc, char* argv[])
{
// --- reading of filenames
cout<<"START"<<endl;
if (argc < 2)
{
cerr << "usage: " << argv[0] << " <file list>" << endl;
return 1;
}
cout << " reading file names from " << argv[1] << endl;
ifstream fileList(argv[1]);
if (!fileList.good() || !fileList.is_open())
{
cerr << " Error, cannot read file list " << argv[1] << endl;
return 1;
}
//FIXME
std::vector<std::string> offBranches;
offBranches.push_back("eventTree.fEvent.fRecEvent.fBeam");
offBranches.push_back("eventTree.fEvent.fRawEvent.fBeam");
std::vector<std::string> onBranches;
onBranches.push_back("eventTree.fEvent.fRawEvent.fBeam");
onBranches.push_back("eventTree.fEvent.fRecEvent.fBeam");
// --- creating of handlers
// ----- List of handlers
HandlerList* HandList = new HandlerList();
// ----- Handlers
const int N0 = 3;
OneWindHandler* arOneWindHandler[N0];
for (int i = 0; i<N0; i++){
TString name;
TString nameBasic = "One_Wind";
char name2[50];
sprintf(name2, "_%i", i);
name = nameBasic + name2;
arOneWindHandler[i] = new OneWindHandler(name + "Raw.root", false);
arOneWindHandler[i]->AddStandardCutsRaw();
if (i==1)
arOneWindHandler[i]->AddAcceptRapidityCut(0.95);
if (i==2)
arOneWindHandler[i]->AddAcceptRapidityCut(0.99);
// arOneWindHandler[i]->AddS5TracksCloudCut(80,100,200,nTrackInVtxFit);
// arOneWindHandler[i]->AddPSDEnergyCut(1470, e28Central);
HandList->AddHandler(arOneWindHandler[i]);
}
const int N1=0;//1;
PtNFluctuationHandler* arHandlerFlucPtNRaw[N1];
for (int i =0; i<N1; i++){
TString name;
TString nameBasic="Full_FlucPt";
char name2[50];
sprintf(name2,"_%i",i);
name = nameBasic + name2;
arHandlerFlucPtNRaw[i] = new PtNFluctuationHandler(name + "Raw.root", false);
arHandlerFlucPtNRaw[i]->AddStandardCutsRaw();
if (i==0 || i==1)
arHandlerFlucPtNRaw[i]->AddCentrality(0,1);
if (i==2 || i==3)
arHandlerFlucPtNRaw[i]->AddCentrality(1,5);
if (i==4 || i==5)
arHandlerFlucPtNRaw[i]->AddCentrality(5,10);
if (i==6 || i==7)
arHandlerFlucPtNRaw[i]->AddCentrality(10,15);
if (i==1 || i==3 || i==5 || i==7)
arHandlerFlucPtNRaw[i]->AddAcceptRapidityCut(0.95);
else arHandlerFlucPtNRaw[i]->AddAcceptRapidityCut(0.9);
//arHandlerFlucPtNRaw[i]->AddPSDEnergyCut(0, 80);
// if (i == 1)
// arHandlerFlucPtNRaw[i]->AddAcceptRapidityCut();
// arHandlerFlucPtNRaw[i]->AddPSDEnergyCut(0, 1850);
// if (i == 1)
// arHandlerFlucPtNRaw[i]->AddPSDEnergyCut(0, 4*beamMomentum);
// if (i == 2)
// arHandlerFlucPtNRaw[i]->AddPSDEnergyCut(0, 2600);
// if (i == 3)
// arHandlerFlucPtNRaw[i]->AddPSDEnergyCut(0, 17 * beamMomentum);
HandList->AddHandler(arHandlerFlucPtNRaw[i]);
}
const int N2 = 0;//3;
PSDFluctuationHandler* arHandlerFlucPSDRaw[N2];
for (int i = 0; i<N2; i++){
TString name;
TString nameBasic = "Full_FlucPSD";
char name2[50];
sprintf(name2, "_%i", i);
name = nameBasic + name2;
arHandlerFlucPSDRaw[i] = new PSDFluctuationHandler(name + "Raw.root", false);
if (i==0 || i==1)
arHandlerFlucPSDRaw[i]->AddRunNumberCut(0,20445);
if (i==2 || i==3)
arHandlerFlucPSDRaw[i]->AddRunNumberCut(20445,20500);
arHandlerFlucPSDRaw[i]->AddStandardCutsRaw();
if (i==1 || i==3)
arHandlerFlucPSDRaw[i]->AddPSDEnergyCut(1850, e28Central);
HandList->AddHandler(arHandlerFlucPSDRaw[i]);
}
const int N3 =0;//21;
PtNFluctuationHandler* arHandlerEtaFlucPtNRaw[N3];
for (int i = 0; i<N3; i++){
TString name;
TString nameBasic = "Eta_FlucPtRaw";
char name2[50];
sprintf(name2, "_%i", i);
name = nameBasic + name2;
arHandlerEtaFlucPtNRaw[i] = new PtNFluctuationHandler(name + "Raw.root", false);
arHandlerEtaFlucPtNRaw[i]->AddRunNumberCut(0,20380);
arHandlerEtaFlucPtNRaw[i]->AddStandardCutsRaw();
arHandlerEtaFlucPtNRaw[i]->AddPSDEnergyCut(1850, e28Central);
//arHandlerEtaFlucPtNRaw[i]->AddEtaCut(2 + i*0.2, 2.5 + i*0.2);
HandList->AddHandler(arHandlerEtaFlucPtNRaw[i]);
}
const int N4 = 0;
TimeHandler* arTime[N4];
for (int i =0; i<N4; i++){
TString name;
TString nameBasic = "Time";
char name2[50];
sprintf(name2, "_%i", i);
name = nameBasic + name2;
arTime[i] = new TimeHandler(name + "Raw.root", false);
arTime[i]->AddStandardCutsRaw();
if (i==1)
arTime[i]->AddPSDEnergyCut(0,900, e28Central);
HandList->AddHandler(arTime[i]);
}
const int N6 = 0;
OneWindHandler* arOneWindHandler1[N6];
for (int i = 0; i<N6; i++){
if (i==3) continue;
if (i==8) continue;
TString name;
TString nameBasic = "One_Wind";
char name2[50];
sprintf(name2, "_%i", i);
name = nameBasic + name2;
arOneWindHandler1[i] = new OneWindHandler(name + "Raw.root", false);
arOneWindHandler1[i]->Raw();
if (systemType == ArSc) {
if (i>0)
arOneWindHandler1[i]->Remove0BinsEvents();
if (i>1)
arOneWindHandler1[i]->RemoveBadRuns();
if (beamMomentum == 150) {
if (i>2)
arOneWindHandler1[i]->AddRunNumberCut(0,20380);
}
if (beamMomentum == 13) {
if (i>2)
arOneWindHandler1[i]->AddRunNumberCut(20551,30000);
}
}
arOneWindHandler1[i]->AddTrigger(T2);
if (systemType == ArSc) {
if (i>3)
arOneWindHandler1[i]->AddWFACut(-100, -200, 4);
if (i>4)
arOneWindHandler1[i]->AddWFAT4Cut(0,1000,25);
}
if (i>5)
arOneWindHandler1[i]->AddStrongPBDCut();
arOneWindHandler1[i]->AddFittedVtxCut();
if (i>8)
arOneWindHandler1[i]->AddFitQualityCut();
if (systemType == ArSc){
if (beamMomentum == 150) {
if (i>9)
arOneWindHandler1[i]->AddZVtxCut(-589.7, -569.7);
if (i>10)
arOneWindHandler1[i]->AddPSDEnergyCut(2800, e16Central);
if (i>11)
arOneWindHandler1[i]->AddPSDEnergyCut(800, 5000, e28Periferal);
if (i>6)
arOneWindHandler1[i]->AddBPD3ClusterSignalCut(3200,8100,2500,7000);
if (i>14)
arOneWindHandler1[i]->AddS5Cut(170);
if (i>15)
arOneWindHandler1[i]->AddS5Cut(50);
if (i>12)
arOneWindHandler1[i]->AddLocalRatioCut(0.25,0,50);
//this->AddTrackVtxFittedTrackRatioCut(0.25);
}
if (beamMomentum == 75){
if (i>9)
arOneWindHandler1[i]->AddZVtxCut(-589.7, -569.7);
if (i>10)
arOneWindHandler1[i]->AddPSDEnergyCut(1300, e16Central);
if (i>11)
arOneWindHandler1[i]->AddPSDEnergyCut(300, 1700, e28Periferal);
if (i>14)
arOneWindHandler1[i]->AddS5Cut(170);
if (i>15)
arOneWindHandler1[i]->AddS5Cut(90);
if (i>6)
arOneWindHandler1[i]->AddBPD3ClusterSignalCut(3800,7200,3600,6800);
if (i>12)
arOneWindHandler1[i]->AddLocalRatioCut(0.17,0,30);
}
if (beamMomentum == 13){
if (i==11) continue;
if (i>9)
arOneWindHandler1[i]->AddZVtxCut(-590, -570);
if (i>10)
arOneWindHandler1[i]->AddPSDEnergyCut(200, e16Central);
if (i>14)
arOneWindHandler1[i]->AddS5Cut(170);
if (i>6)
arOneWindHandler1[i]->AddBPD3ClusterSignalCut(3000,7900,2500,6800);
if (i>12)
arOneWindHandler1[i]->AddLocalRatioCut(0.08,0,6);
}
if (beamMomentum == 19) {
if (i>9)
arOneWindHandler1[i]->AddZVtxCut(-589.9, -569.9);
if (i>10)
arOneWindHandler1[i]->AddPSDEnergyCut(350, e16Central);
if (i>11)
arOneWindHandler1[i]->AddPSDEnergyCut(20, 500, e28Periferal);
if (i>14)
arOneWindHandler1[i]->AddS5Cut(170);
if (i>15)
arOneWindHandler1[i]->AddS5Cut(90);
if (i>6)
arOneWindHandler1[i]->AddBPD3ClusterSignalCut(3500, 6500, 3200, 6000);
if (i>12)
arOneWindHandler1[i]->AddLocalRatioCut(0.1,0,10);
}
if (beamMomentum == 30) {
if (i>9)
arOneWindHandler1[i]->AddZVtxCut(-589.9, -569.9);
if (i>10)
arOneWindHandler1[i]->AddPSDEnergyCut(600, e16Central);
if (i>11)
arOneWindHandler1[i]->AddPSDEnergyCut(100, 1000, e28Periferal);
if (i>14)
arOneWindHandler1[i]->AddS5Cut(170);
if (i>15)
arOneWindHandler1[i]->AddS5Cut(90);
if (i>6)
arOneWindHandler1[i]->AddBPD3ClusterSignalCut(3400,7400,2800,6600);
if (i>12)
arOneWindHandler1[i]->AddLocalRatioCut(0.1,0,12);
}
if (beamMomentum == 40) {
if (i>9)
arOneWindHandler1[i]->AddZVtxCut(-589.8, -569.8);
if (i>10)
arOneWindHandler1[i]->AddPSDEnergyCut(900, e16Central);
if (i>11)
arOneWindHandler1[i]->AddPSDEnergyCut(200, 1000, e28Periferal);
if (i>14)
arOneWindHandler1[i]->AddS5Cut(170);
if (i>15)
arOneWindHandler1[i]->AddS5Cut(90);
if (i>6)
arOneWindHandler1[i]->AddBPD3ClusterSignalCut(3500,8000,3000,7000);
if (i>12)
arOneWindHandler1[i]->AddLocalRatioCut(0.13,0,15);
}
}
if (i>13)
arOneWindHandler1[i]->AddZeroPositiveTracksCut();
arOneWindHandler1[i]->AddStandardCutsRaw();
HandList->AddHandler(arOneWindHandler1[i]);
}
const int N7 = 0;
LRCHandler* arLRCHandler[N7];
for (int i = 0; i<N7; i++){
TString name;
TString nameBasic = "LRC_Wind";
char name2[50];
sprintf(name2, "_%i", i);
name = nameBasic + name2;
arLRCHandler[i] = new LRCHandler(name + "Raw.root", false);
arLRCHandler[i]->AddStandardCutsRaw();
arLRCHandler[i]->AddEtaForward(5.5, 6);
arLRCHandler[i]->AddEtaBackward(3.2 + i*0.2, 3.7 + i*0.2);
HandList->AddHandler(arLRCHandler[i]);
}
const int N8 = 0;
PSDHandler* arPSDHandler[N8];
for (int i = 0; i<N8; i++){
TString name;
TString nameBasic = "PSD";
char name2[50];
sprintf(name2, "_%i", i);
name = nameBasic + name2;
arPSDHandler[i] = new PSDHandler(name + "Raw.root", false);
arPSDHandler[i]->AddStandardCutsRaw();
arPSDHandler[i]->AddS5Cut(80);
if (i==1)
arPSDHandler[i]->Remove0EPSDEvents(e28Central);
HandList->AddHandler(arPSDHandler[i]);
}
const int N9 = 0;
PSD0BinsFindHandler* ar0bins[N9];
for (int i = 0; i<N9; i++){
TString name;
TString nameBasic = "0Bins";
char name2[50];
sprintf(name2, "_%i", i);
name = nameBasic + name2;
ar0bins[i] = new PSD0BinsFindHandler(name + "Raw.root", false);
ar0bins[i]->Raw();
if (i==1)
ar0bins[i]->AddFPGACut(eAll);
// ar0bins[i]->Remove0BinsEvents();
HandList->AddHandler(ar0bins[i]);
}
//FIXME: add information about energy and system type inside names of hists!
cout<<"Initialization"<<endl;
HandList->Init();
int i=0;
time_t now;
struct tm *ts;
char buf[80];
int nFiles = 0;
while (true){
string fileName;
fileList >> fileName;
if(!fileList.good())
break;
cout << " ->processing " << fileName << endl;
EventFile eventFile(fileName, eRead, Verbosity::eSilent, offBranches, onBranches);
Event event;
cout<<"event loop ... "<<endl;
// --- loop over events
while (eventFile.Read(event) == eSuccess){
i++;
// cout<<"event_event"<<i<<endl;
// --- working status output
cout<<i<<"\t";
if(i%1000==0){
// Get the current time
now = time(NULL);
// Format and print the time, "ddd yyyy-mm-dd hh:mm:ss zzz"
ts = localtime(&now);
strftime(buf, sizeof(buf), "%a %Y-%m-%d %H:%M:%S %Z", ts);
printf("running event %5d time: %s\n",(int) i,buf);
}
CutList::eventCutChecking.Reset();
// cout<<"eat"<<endl;
HandList->EatEvent(event);
}
}
delete HandList;
return 0;
}
