QNeighboursFiller.cc

Go to the documentation of this file.

#include "QNeighboursFiller.hh"
#include "QEventAssembler.hh"
#include "QEventList.hh"
#include "QReader.hh"
#include "QReaderNeighbour.hh"
#include "QReaderNeighbourFactory.hh"
 
 
Q_BEGIN_NAMESPACE
 
QNeighboursFiller::QNeighboursFiller(QReader* reader){
    fReader = reader;
    fReaderNeighbour = 0;
}
 
QNeighboursFiller::~QNeighboursFiller(){
    if(fReaderNeighbour) delete fReaderNeighbour;
}
 
 
void QNeighboursFiller::Init(QEventAssembler& eva){
    std::string rnname  = fReader->GetString("NeighbourAlgorithm","");
    fReaderNeighbour = QReaderNeighbourFactory(rnname);
    if(!fReaderNeighbour) fReader->Panic("NeighbourAlgorithm %s not known",rnname.c_str());
    fNeighboursReloading=fReader->GetBool("NeighboursReloading",true,true);
    fMaxEventIndex = (size_t)fReader->GetInt("MaximumEventIndexInBuffer",1000,false);
    fReaderNeighbour->InitBase(*fReader);
    fEventIndex = 0;
    fEventList.Clear();
    fEvalNeighbours.clear(); 
 
    fEva.Assign(eva.GetEvent());
    fEndOfEvents = false;
    fReader->Init(fEva);
    eva.Assign(fEva.GetEvent());
    eva.GetAliases() = fEva.GetAliases();
    
    fFillStrategy = fReader->GetInt("NeighbourFillStrategy",fReaderNeighbour->GetFillStrategy(),false);
 
}
 
bool QNeighboursFiller::Do(QEventAssembler& evao, QEventList& neighbours)
{
    if(fEndOfEvents && fEventIndex == fEventList.Size()) return false;
    if(fEventIndex == 0) { 
        fEva.Assign(evao.GetEvent());
        fEva.Consolidate();
    }
    // At this point fEventIndex corresponds to the event that will be
    // read out at the end of Do. But evao, contains the data from the
    // last event.
    bool EnterMainLoop=true;
    StartProcessCall();
    std::cout<<"AOOOOOO    "<<EnterMainLoop<<std::endl; 
    if(fFillStrategy == QReaderNeighbour::kAssociativeFillStrategy)
        EnterMainLoop=AssociativeFillNeighbours(evao,neighbours);
    else if(fFillStrategy == QReaderNeighbour::kFilterFillStrategy)
        EnterMainLoop=FilterFillNeighbours(evao,neighbours);
    else
        EnterMainLoop=ExhaustiveFillNeighbours(evao,neighbours);
    std::cout<<"AOOOOOO2    "<<EnterMainLoop<<std::endl; 
    if(!EnterMainLoop) return false;
 
    // Fill the data from the event in the cached list into the event assembler
    evao.Assign(fEventList[fEventIndex].GetEvent()); 
   
    EndProcessCall();
 
    fEventIndex++; // Increment fEventIndex for the next call
 
    return true;
}
 
bool QNeighboursFiller::AssociativeFillNeighbours(QEventAssembler& evao, QEventList& neighbours) {
    // For this method, we are going to assume that fIsInWindow and
    // fIsNeighbour are interchangable. Because of that, we dont need
    // to check if each event in the fEventList belongs in
    // neighbours. Instead, we simply do quick searches for the first
    // InWindow in EventList, and know that the last event in
    // fEventList is not a neighbour of the previous event. So, things
    // are a lot faster.
 
    neighbours.Clear();
    const QEvent* currEv = 0;
    if(!fEventList.Empty()) currEv = &(fEventList[fEventIndex].GetEvent());
 
    QReaderNeighbour::NeighbourInfo nInfo;
  
 
    // Start with two most likely places that the first neighbour
    // could be (e.g. the first event in fEventList, and the event
    // before fEventIndex).
    int firstNeighbour = -1;
    if(fEventIndex>0) {
        nInfo = GetNeighbourInfo(*currEv,fEventList[0].GetEvent());
        if(nInfo.fIsInWindow) // Maybe the first event in fEventList is a neighbour?
                firstNeighbour = 0;
        if(firstNeighbour < 0) { // Maybe fEventIndex is not a neighbour?
                nInfo = GetNeighbourInfo(*currEv,fEventList[fEventIndex-1].GetEvent());
                if(!nInfo.fIsInWindow)
                    firstNeighbour = fEventIndex;
        }
        if(firstNeighbour < 0) { // Otherwise, do a binary search for the first neighbour
                int start = 0;
                int end = fEventIndex - 1;
                firstNeighbour = fEventIndex - 1;
                while(start<=end) {
                    int mid = (start+end)/2;
                    nInfo = GetNeighbourInfo(*currEv,fEventList[mid].GetEvent());
                    if(nInfo.fIsInWindow) {
                        firstNeighbour = mid;
                        end = mid - 1;
                    }else {
                        start = mid + 1;
                    }
                }
        }
    }
    // Pop all the things that are behind and can be dropped from
    // consideration.
    for(int i=0;i<firstNeighbour;i++) {
        fEventList.Pop();
        fEventIndex--;
    }
 
    // Fill all the past events from 0 to fEventIndex-1
    for(size_t iev=0;iev<fEventIndex;iev++) {
        if(iev == fEventIndex - 1)
                fEventList[iev].Assign(evao.GetEvent());
        neighbours.Push(&(fEventList[iev].GetEvent()));
    }
 
 
    // Test the last event in fEventList, if its a neighbour we'll
    // need to read more, if its not a neighbour, don't read
    // anymore. Eitherway, we are going to fill all of the events from
    // fEventIndex up to fEventList.Size()-1 into neighbours.
    bool futureEventLeft = false;
    if(fEventList.Size()>1) {
        nInfo = GetNeighbourInfo(*currEv,fEventList[fEventList.Size()-1].GetEvent());
        futureEventLeft = !nInfo.fIsInWindow;
 
        for(size_t iev=fEventIndex+1;iev < fEventList.Size()-futureEventLeft;iev++)
                neighbours.Push(&(fEventList[iev].GetEvent()));
    }
 
 
    // get new events
    if(!futureEventLeft && !fEndOfEvents) {
        bool isInWindow = false;
        do {
            fEva.Clear();
            fEndOfEvents = !fReader->DoBase(fEva);
            if(fEndOfEvents) break;
 
            fEventList.Push(fEva.GetEvent());
            if(fEventList.Size() == 1) {
                currEv = &(fEventList[0].GetEvent());
                isInWindow = true;
            } else {
                const QEvent& otherEv  = fEventList.Back().GetEvent();
                nInfo = GetNeighbourInfo(*currEv,otherEv);
                isInWindow = nInfo.fIsInWindow;
                if(nInfo.fIsNeighbour) neighbours.Push(&otherEv);
            }
        } while (isInWindow && !fEndOfEvents);
    }
 
    return true;
}
 
bool QNeighboursFiller::ExhaustiveFillNeighbours(QEventAssembler& evao, QEventList& neighbours) {
    //    fReader->Warn("EventList size %d",fEventList.Size());
    neighbours.Clear();
    const QEvent* currEv = 0;
    if(!fEventList.Empty()) currEv = &(fEventList[fEventIndex].GetEvent());
        
 
    QReaderNeighbour::NeighbourInfo nInfo;
 
    // Start from the beginning of the cached event list. And test
    // whether each of the events before fEventIndex is in window and
    // a neighbour.
    for(int iev = 0; iev < (int)fEventIndex; iev++) {
        QEvent& otherEv = fEventList[iev].GetEvent();
        nInfo = GetNeighbourInfo(*currEv,otherEv);
        if(!nInfo.fIsInWindow) {
        fEventList.Pop(); // If the event is not in the window, drop it from cache
            fEventIndex--;
            iev--;
        } else {
            if(iev == int(fEventIndex -1)) {
            // What we are doing here, is assigning the data in
            // evao (some of which was calculated in the last
            // round of Do's) to the cached data in the list.
                fEventList[iev].Assign(evao.GetEvent());
            }
            if(nInfo.fIsNeighbour)
            // If its a neighbour, add it to the list of neighbours.
                neighbours.Push(&otherEv);
        }
    }
    evao.Clear(); // Clear the data from the last event (fEventIndex-1).
 
    // forward events in list
    bool futureEventLeft = false;
    for(size_t iev = fEventIndex+1; iev < fEventList.Size(); iev++) {
        const QEvent& otherEv = fEventList[iev].GetEvent();
        nInfo = GetNeighbourInfo(*currEv,otherEv);
        if(nInfo.fIsInWindow && nInfo.fIsNeighbour)
            neighbours.Push(&otherEv);
        else if(!nInfo.fIsInWindow)
            futureEventLeft = true;
    }
 
    // get new events
        std::cout<<"ExhaustiveFillNeighbours"<<std::endl;       
    if(!futureEventLeft && !fEndOfEvents) {
        bool isInWindow = false;
        do {
            fEva.Clear();
            fEndOfEvents = !fReader->DoBase(fEva);
            if(fEndOfEvents) break;
 
            fEventList.Push(fEva.GetEvent());
            if(fEventList.Size() == 1) {
                currEv = &(fEventList[0].GetEvent());
                isInWindow = true;
            } else {
                const QEvent& otherEv  = fEventList.Back().GetEvent();
                nInfo = GetNeighbourInfo(*currEv,otherEv);
                isInWindow = nInfo.fIsInWindow;
                if(nInfo.fIsNeighbour) neighbours.Push(&otherEv);
            }
        } while (isInWindow && !fEndOfEvents);
    }
 
    return true;
}
 
 
bool QNeighboursFiller::FilterFillNeighbours(QEventAssembler& evao, QEventList& neighbours) {
    
    neighbours.Clear(); //clear neighbours
    const QEvent* currEv = 0; //pointer to data of current event being evaled
    bool eval_neigh = false; //<- tells us if we want to enter in the event loop
    QReaderNeighbour::NeighbourInfo nInfo; //initialize info
 
    //Loop until you find the main event that wants neighbours
    do{
        //If list is not empty then assign current event
        if(!fEventList.Empty()){
            currEv = &(fEventList[fEventIndex].GetEvent());
            eval_neigh=fEvalNeighbours[fEventIndex];
        }
        
        //Quickly empty the fEventList every now and then in order to not make 
        //cache diverge. Only do this for events that don't want the neighbours,
        //since the cache is correctly emptied when the neighbour algo is called.
        if(!eval_neigh and fEventIndex>fMaxEventIndex){
            size_t other_evidx=fEventIndex/2;
            nInfo = GetNeighbourInfo(*currEv,fEventList[other_evidx].GetEvent());
            if(!nInfo.fIsInWindow){
                for(size_t iev = 0; iev <other_evidx; iev++){
                    fEventList.Pop();
                    fEvalNeighbours.pop_front();
                    fEventIndex--;
                    other_evidx--;
                    iev--;
                }
            }
        }
        //Reload past event if we want (very slow, deprecated). 
        //Since we only enter the main diana event loop there is no need to add events
        //that don't want neighbours since they remain unchanged.
        if(fEventIndex>0 and fNeighboursReloading) {
            // What we are doing here, is assigning the data in
            // evao (some of which was calculated in the last
            // round of Do's) to the cached data in the list.
            if(fEvalNeighbours[fEventIndex-1]) fEventList[fEventIndex-1].Assign(evao.GetEvent());
        }
        
        //if we are not in presence of a master event but we have finished 
        //the fEventList then we must read 1 new event from the file. If we
        //are in the presence of a master event then it will be taken care of 
        //after.
        if((!eval_neigh and !fEndOfEvents) and (fEventIndex+1 == fEventList.Size() or (fEventIndex==fEventList.Size() and fEventList.Size()==0))){
            fEva.Clear();
            fEndOfEvents = !fReader->DoBase(fEva);
            if(!fEndOfEvents){
                fEventList.Push(fEva.GetEvent());//<- this is a costly operation
                fEvalNeighbours.push_back(GetWantsNeighbours(fEva.GetEvent()));
            }
        }
 
        //Move to next event in cache if not a master event, otherwise the main loop 
        //takes care of it
        if(!eval_neigh and fEventList.Size()>1){
            fEventIndex++;
        }
    }while(!eval_neigh and !(fEndOfEvents and fEventIndex==fEventList.Size())); //exit if we have master event or if we finished the events
    
    //If it is not a master event and we are at the end of the cache and at the end of
    //the file the event must not be processed
    if(!eval_neigh and fEventIndex==fEventList.Size() and fEndOfEvents) return false;
 
    //From this point on we are sure that we have an event that wants neighbours.
    //So we assume eval_neigh=true (and all that it implies :3 ).
 
    // Start from the beginning of the cached event list. And test
    // whether each of the events before fEventIndex is in window and
    // a neighbour.
    for(int iev = 0; iev < (int)fEventIndex; iev++) {
        QEvent& otherEv = fEventList[iev].GetEvent();
        nInfo = GetNeighbourInfo(*currEv,otherEv);
        if(!nInfo.fIsInWindow) {
            // If the event is not in the window, drop it from cache
            fEventList.Pop(); 
            fEvalNeighbours.pop_front();
            fEventIndex--;
            iev--;
        } else {
            if(nInfo.fIsNeighbour)
                // If its a neighbour, add it to the list of neighbours.
                neighbours.Push(&otherEv); 
        }
    }
 
    evao.Clear(); // Clear the data from the last event (fEventIndex-1).
 
    bool futureEventLeft = false;
    // forward events in list
    for(size_t iev = fEventIndex+1; iev < fEventList.Size(); iev++) {
        const QEvent& otherEv = fEventList[iev].GetEvent();
        nInfo = GetNeighbourInfo(*currEv,otherEv);
        if(nInfo.fIsInWindow && nInfo.fIsNeighbour) 
            neighbours.Push(&otherEv);
        else if(!nInfo.fIsInWindow)
            futureEventLeft = true;
    }
 
    // get new events
    if(!futureEventLeft && !fEndOfEvents) {
        bool isInWindow = false;
        do {
            fEva.Clear();
            fEndOfEvents = !fReader->DoBase(fEva);
            if(fEndOfEvents) break;
            
            fEventList.Push(fEva.GetEvent());//<- this is a costly operation
 
            fEvalNeighbours.push_back(GetWantsNeighbours(fEva.GetEvent()));
            if(fEventList.Size() == 1) {
                currEv = &(fEventList[0].GetEvent());
                eval_neigh=fEvalNeighbours[0];
            }
 
            if(fEventList.Size() == 1) {
                isInWindow = true;
            } else{
                const QEvent& otherEv  = fEventList.Back().GetEvent();
                nInfo = GetNeighbourInfo(*currEv,otherEv);
                isInWindow = nInfo.fIsInWindow;
                if(nInfo.fIsNeighbour) neighbours.Push(&otherEv);
            }
        } while (isInWindow && !fEndOfEvents);
    }
    
    return true;
}
 
QReaderNeighbour::NeighbourInfo QNeighboursFiller::GetNeighbourInfo(const QEvent& thisEvent, const QEvent& otherEvent){
    return fReaderNeighbour->GetNeighbourInfoBase(thisEvent,otherEvent); 
}
 
bool QNeighboursFiller::GetWantsNeighbours(const QEvent& thisEvent){
    return fReaderNeighbour->GetWantsNeighbours(thisEvent); 
}
 
Q_END_NAMESPACE