/home/alex/Work/Research/Km3NeT/PPM-DU/ppm-du-v2.3/triggeringDOM.cc

Go to the documentation of this file.

#include "triggeringDOM.h"

#include <algorithm>
#include <iostream>

void
FillSignals(const signals sig, std::vector<signals>& vSig)
{
  vSig.push_back(sig);
}

void
SortSignals(std::vector<signals>& vSig)
{
  std::sort(vSig.begin(), vSig.end());
}
/*
bool
FindNeighbours(const int id1, std::vector<int>& id2) {
  int ring = 0;
  int position = 0;
  int offset = 1;
  id2.resize(neighbourNb);
  if (id1 > 0) {
    ring = int((id1 - 1)/6) + 1;
    position = id1 - (ring - 1)*6 - 1;
  }
  if (ring%2) offset = 0;

  int nextPosition = position;
  if (ring == 0) {
    id2[0] = -1;
    id2[1] = -1;    
  } else {
    nextPosition = position - 1 + offset;
    if (nextPosition < 0) nextPosition = 5;
    id2[0] = pmtMap[ring - 1][nextPosition];
    nextPosition = position + offset;
    if (nextPosition > 5) nextPosition = 0;
    id2[1] = pmtMap[ring - 1][nextPosition];
  }
  nextPosition = position - 1;
  if (nextPosition < 0) nextPosition = 5;
  id2[2] = pmtMap[ring][nextPosition];
  nextPosition = position + 1;
  if (nextPosition > 5) nextPosition = 0;
  id2[3] = pmtMap[ring][nextPosition];
  if (ring == 5) {
    id2[4] = -1;
    id2[5] = -1;
  } else {
    nextPosition = position - 1 + offset;
    if (nextPosition < 0) nextPosition = 5;
    id2[4] = pmtMap[ring + 1][nextPosition];
    nextPosition = position + offset;
    if (nextPosition > 5) nextPosition = 0;
    id2[5] = pmtMap[ring + 1][nextPosition];
  }
  return true;
}

bool
AreNeighbours(const int id1, const int id2)
{
  std::vector<int> neighbourList1;
  std::vector<int> neighbourList2;
  neighbourList1.resize(neighbourNb);
  neighbourList2.resize(neighbourNb);
  for (int i = 0; i < neighbourNb; ++i) {
    neighbourList1[i] = 0;
    neighbourList2[i] = 0;
  }
  FindNeighbours(id1, neighbourList1);
  FindNeighbours(id2, neighbourList2);
  for (int i = 0; i < neighbourNb; ++i) {
    if ((neighbourList1[i] == id2) || (neighbourList2[i] == id1)) {
      return true;
    }
  }
  return false;
}
*/

bool
AreNeighbours(const int id1, const int id2)
{
  for (int i = 0; i < neighbourNb; ++i) {
    if (neighbour[id1][i] == id2) return true;
  }
  return false;   
}

bool
DoT2Pmts(const std::vector<signals>& vSig, std::vector<triggeredSignals>& vTrig)
{
  if (vSig.size() < 2)
    return false;
  for (unsigned int i = 0; i < (vSig.size() - 1); ++i) {
    const long long int stop1 = vSig[i].GetStop();
    const long long int start2 = vSig[i + 1].GetStart();
    if (stop1 > start2) {
      triggeredSignals tSig("T2Pmts");
      tSig.AddSignal(vSig[i]);
      tSig.AddSignal(vSig[i + 1]);
      vTrig.push_back(tSig);
    }
  }
  return true;
}

bool
DoT2Pmts(const std::vector<signals>& vSig, std::vector<triggeredSignals>& vTrig,
         const int coincWindow)
{
  if (vSig.size() < 2)
    return false;
  for (unsigned int i = 0; i < (vSig.size() - 2); ++i) {
    const int dom1 = vSig[i].GetDomId();
    const int dom2 = vSig[i + 1].GetDomId();
    const int dom3 = vSig[i + 2].GetDomId();
    if (dom1 != dom2) continue;
    const long long int start1 = vSig[i].GetStart();
    const long long int start2 = vSig[i + 1].GetStart();
    const long long int start3 = vSig[i + 2].GetStart();
    if (start2 > start1 + coincWindow) {
      continue;
    } else {
      triggeredSignals tSig1("T2Pmts");
      tSig1.AddSignal(vSig[i]);
      tSig1.AddSignal(vSig[i + 1]);
      vTrig.push_back(tSig1);
      if (dom1 != dom3) continue;
      if (start3 > start1 + coincWindow) {
        ++i;
        continue;
      } else {
        triggeredSignals tSig2("T2Pmts");
        tSig2.AddSignal(vSig[i + 1]);
        tSig2.AddSignal(vSig[i + 2]);
        vTrig.push_back(tSig2); 
        triggeredSignals tSig3("T2Pmts");
        tSig3.AddSignal(vSig[i]);
        tSig3.AddSignal(vSig[i + 2]);
        vTrig.push_back(tSig3); 
        ++i;
        ++i;
      }
    }
  }
  return true;
}

bool
DoT2Pmts(const std::vector<signals>& vSig, std::vector<triggeredSignals>& vTrig,
         const int coincWindow, const int refId)
{
  if (vSig.size() < 2)
    return false;
  for (unsigned int i = 0; i < (vSig.size() - 1); ++i) {
    const long long int start1 = vSig[i].GetStart();
    const long long int start2 = vSig[i + 1].GetStart();
    if (start2 > start1 + coincWindow) {
      continue;
    } else {
      const int id1 = vSig[i].GetPmtId();
      const int id2 = vSig[i + 1].GetPmtId();
      if ((id1 == refId) || (id2 == refId)) {
        triggeredSignals tSig("T2Pmts");
        tSig.AddSignal(vSig[i]);
        tSig.AddSignal(vSig[i + 1]);
        vTrig.push_back(tSig);
      }
    }
  }
  return true;
}

bool
DoSlidingT(const std::vector<signals>& vSig, std::vector<triggeredSignals>& vTrig)
{
  if (vSig.size() < 2) {
    return false;
  }
  bool trigger = false;
  triggeredSignals tSig("SlidingT");
  for (unsigned int i = 0; i < (vSig.size() - 1); ++i) {
    const long long int stop1 = vSig[i].GetStop();
    const long long int start2 = vSig[i + 1].GetStart();
    if (stop1 > start2) {
      if (trigger == false) {
        trigger = true;
        tSig.AddSignal(vSig[i]);
        tSig.AddSignal(vSig[i + 1]);
      } else {
        tSig.AddSignal(vSig[i + 1]);    
      } 
    } else {
      if (trigger == true) {
        trigger = false;
        vTrig.push_back(tSig);
        tSig.Clear();
      }
    }
  }
  return true;
}

bool
DoTmultiPmts(const std::vector<signals>& vSig, std::vector<triggeredSignals>& vTrig,
             const int coincWindow)
{
  if (vSig.size() < 2)
    return false;
  //bool endTrigger = false;
  triggeredSignals tSig("TmultiPmts");
  for (unsigned int i = 0; i < (vSig.size() - 1); ++i) {
    //if (endTrigger == true) {
    //  if (tSig.GetTriggeredPmt() > 1) {
    //  vTrig.push_back(tSig);
    //  } 
    //} 
    tSig.Clear();
    long long int start1 = vSig[i].GetStart();
    tSig.AddSignal(vSig[i]);
    int domId1 = vSig[i].GetDomId();
    int coincCounter = 0;
    bool hasTrigger = false;
    for (unsigned int j = i + 1; j < vSig.size(); ++j) {
      const long long int start2 = vSig[j].GetStart();
      const int domId2 = vSig[j].GetDomId();
      if (domId2 != domId1) continue;
      if (start2 > start1 + coincWindow) {
        if (hasTrigger == true) vTrig.push_back(tSig);
        hasTrigger = false;
        //endTrigger = true;
        break;
      } else if (start2 < start1) {
        //endTrigger = true;
        break;
      } else {
        hasTrigger = true;
        ++coincCounter;
        tSig.AddSignal(vSig[j]);
      }
    }
    if (hasTrigger == true) vTrig.push_back(tSig);
    i += coincCounter;
  }
  return true;
}

bool 
SelectingMultiplicity(std::vector<triggeredSignals>& vTrigInit,
                      std::vector<triggeredSignals>& vTrigFinal, const int multiplicity)
{
  for (unsigned int ev = 0; ev < vTrigInit.size(); ++ev) {
    const std::vector<signals> vSig = vTrigInit[ev].GetSignals();
    if (vSig.size() >= unsigned(multiplicity)) vTrigFinal.push_back(vTrigInit[ev]);
  }
  return true;
}