MNeighboursPacker.cc

Go to the documentation of this file.

#include "MNeighboursPacker.hh"
#include "QEventAssembler.hh"
#include "QEventList.hh"
#include <sstream>
#include "QBaseType.hh"
#define NSPACER "_"
 
REGISTER_MODULE(MNeighboursPacker)
 
using namespace Diana;
 
 
QDriver::Action MNeighboursPacker::Init(QEventAssembler& eva) 
{ 
    fMaxNeighbours = GetInt("MaximumNumberOfNeighbours",2);
    if(fMaxNeighbours < 1) Panic("MaximumNumberOfNeighbours = %d not allowed",fMaxNeighbours);
    fLabels.clear();
    fLabels.resize(fMaxNeighbours);
 
    // retreive aliases from event and from files
    QAliases& aliases = eva.GetAliases();
    std::map<std::string, QVdt*> wparams = GetModuleParameters(GetSequence().GetWriterName(), 0);
 
    if(wparams.find("AliasFileName") != wparams.end()) {
        aliases.FillFromFile(wparams["AliasFileName"]->GetString());
    }
    if(wparams.find("CustomAliasFileName") != wparams.end()) {
        aliases.FillFromFile(wparams["CustomAliasFileName"]->GetString());
    }
    eva.GetEvent().Add<QInt>("NumberOfNeighbours");
 
    // add objects of neigbours events
    std::vector<QEventLabel> originalObjects = eva.GetLabels();
    for(size_t i = 0; i < originalObjects.size(); i++) {
 
        const QEventLabel& label = originalObjects[i];
        if(!GetBool(label,false,false)) continue;
        QObject** object = eva.Get(label.owner.c_str(),label.name.c_str());
        (*object)->SetIsRequired();
 
        for(size_t n = 0; n < (size_t)fMaxNeighbours; n++) {
                        // create new label
            std::stringstream newOwner;
            newOwner<<std::string(GetString("Prefix","N",false));
            newOwner<<n+1;
            newOwner<<NSPACER;
            newOwner<<label.owner;
            QEventLabel newLabel(newOwner.str(),label.name);
            QObject** newObject = eva.Get(newOwner.str().c_str(),label.name.c_str());
            if(newObject == 0) {
                // create new object
                newObject = new (QObject*);
                *newObject = (*object)->Duplicate();
                (*object)->FullyFill(*newObject);
                (*newObject)->SetIsJustAdded();
 
                // add new object to the QEvent
                eva.Add(newLabel.owner.c_str(),newLabel.name.c_str(),newObject);
            } else {
                (*newObject)->SetIsJustAdded();
            }
 
            // store label of new object
            ObjectLabels labels;
            labels.fLabel = newLabel;
            labels.fOriginalLabel = label;
            fLabels[n].push_back(labels);
 
            // set aliases for new object in the form N1#alias
            std::map<std::string,std::string> thisAliases = aliases.Find(label);
            std::map<std::string,std::string>::const_iterator aiter = thisAliases.begin();
            while(aiter != thisAliases.end()) {
                std::stringstream nalias;
                nalias<<std::string(GetString("Prefix","N"));
                nalias<<n+1;
                nalias<<NSPACER;
                nalias<<aiter->first;
                aliases.Add(newLabel,aiter->second,nalias.str());
                aiter++;
            }
 
        }
    }
    if(fLabels[0].empty()) {
        Error("No QObject from neighbours will be packed");
    } else {
        std::stringstream msg;
        msg<<"Packing: ";
        for(size_t n = 0; n < fLabels[0].size(); n++) msg<<fLabels[0][n].fOriginalLabel.GetStringLabel()<<" ";
        msg<<std::endl;
        Info("%s",msg.str().c_str());
    }
 
    fMaxNeighboursAchieved = 0;
    return ACT_NEXTEV;
}
 
QDriver::Action MNeighboursPacker::Do(QEventAssembler& eva, const QEventList& neigh)
{
    for(size_t n = 0; n < neigh.Size(); n++) {
        if(n < (size_t)fMaxNeighbours) {
            for(size_t l = 0; l < fLabels[n].size(); l++) {
                const QEventLabel& label = fLabels[n][l].fLabel;
                const QEventLabel& originalLabel = fLabels[n][l].fOriginalLabel;
                ReadHandle<QObject> rHandle(originalLabel.name.c_str());
                neigh[n].Get(originalLabel.owner.c_str(),rHandle);
                if(rHandle.IsValid())  {
                    const QObject* originalObject = &rHandle.Get();
                    QObject** object = eva.Get(label.owner.c_str(),label.name.c_str());
                    originalObject->FullyFill(*object);
                    (*object)->SetIsJustAdded();
                }
            }
        }
    }
 
    eva.GetEvent().Get<QInt>("NumberOfNeighbours") = neigh.Size();
 
    if(neigh.Size() > fMaxNeighboursAchieved) fMaxNeighboursAchieved = neigh.Size();
 
    return ACT_NEXTEV;
}
 
QDriver::Action MNeighboursPacker::Done()
{
    if(fMaxNeighboursAchieved > (size_t)fMaxNeighbours) 
        Warn("Only %d neighbours per event have been packed, while the maximum number available was %d", fMaxNeighbours, fMaxNeighboursAchieved);
    else if(fMaxNeighboursAchieved < (size_t)fMaxNeighbours)
        Warn("Could not pack %d neighbours per event, since maximum number available was only %d",fMaxNeighbours, fMaxNeighboursAchieved);
    GlobalHandle<QInt> nHandle("NumberOfNeighbours");
    nHandle.Set(fMaxNeighbours);
    GlobalData().Set(&nHandle,"CurrentWriter");
    return ACT_NEXTEV;
}