DATCONSpacePointHelperFunctions.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2010 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Jakob Lettenbichler, Giulia Casarosa, Christian Wessel   *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
 
#include <vector>
 
#include <framework/datastore/StoreArray.h>
 
#include <mdst/dataobjects/MCParticle.h>
#include <svd/dataobjects/SVDTrueHit.h>
 
#include <vxd/dataobjects/VxdID.h>
 
#include <tracking/dataobjects/DATCONSVDSpacePoint.h>
 
#include <unordered_map>
 
namespace Belle2 {
  struct ClustersOnSensor {
 
  public:
 
    inline void addCluster(const SVDCluster* entry)
    {
      vxdID = entry->getSensorID();
      if (entry->isUCluster() == true) { clustersU.push_back(entry); return; }
      clustersV.push_back(entry);
    }
 
    VxdID vxdID;
 
    std::vector<const SVDCluster*> clustersU;
 
    std::vector<const SVDCluster*> clustersV;
 
  };
 
 
  void provideDATCONSVDClusterSingles(const StoreArray<SVDCluster>& DATCONSVDClusters,
                                      StoreArray<DATCONSVDSpacePoint>& spacePoints)
  {
    for (unsigned int i = 0; i < uint(DATCONSVDClusters.getEntries()); ++i) {
      const SVDCluster* currentCluster = DATCONSVDClusters[i];
      std::vector<const SVDCluster*> currentClusterCombi = { currentCluster };
      DATCONSVDSpacePoint* newSP = spacePoints.appendNew(currentClusterCombi);
      newSP->addRelationTo(currentCluster);
    }
  }
 
 
 
  inline void findPossibleCombinations(const Belle2::ClustersOnSensor& aSensor,
                                       std::vector< std::vector<const SVDCluster*> >& foundCombinations)
  {
 
    for (const SVDCluster* uCluster : aSensor.clustersU) {
      //       if (uCluster->getClsTime() < minClusterTime)
      //         continue;
      for (const SVDCluster* vCluster : aSensor.clustersV) {
        //         if (vCluster->getClsTime() < minClusterTime)
        //           continue;
        // cppcheck-suppress useStlAlgorithm
        foundCombinations.push_back({uCluster, vCluster});
 
      }
    }
  }
 
  void provideDATCONSVDClusterCombinations(const StoreArray<SVDCluster>& DATCONSVDClusters,
                                           StoreArray<DATCONSVDSpacePoint>& spacePoints)
  {
    // collects one entry per sensor, each entry will contain all Clusters on it TODO: better to use a sorted vector/list?
    std::unordered_map<VxdID::baseType, Belle2::ClustersOnSensor> activatedSensors;
 
    // collects all combinations of Clusters which were possible (condition: 1u+1v-Cluster on the same sensor)
    std::vector<std::vector<const SVDCluster*> > foundCombinations;
 
 
    // sort Clusters by sensor. After the loop, each entry of activatedSensors contains all U and V-type clusters on that sensor
    for (unsigned int i = 0; i < uint(DATCONSVDClusters.getEntries()); ++i) {
      SVDCluster* currentCluster = DATCONSVDClusters[i];
 
      activatedSensors[currentCluster->getSensorID().getID()].addCluster(currentCluster);
    }
 
    for (auto& aSensor : activatedSensors) {
//       findPossibleCombinations(aSensor.second, foundCombinations, minClusterTime);
      findPossibleCombinations(aSensor.second, foundCombinations);
    }
 
    for (auto& clusterCombi : foundCombinations) {
      DATCONSVDSpacePoint* newSP = spacePoints.appendNew(clusterCombi);
      for (auto* cluster : clusterCombi) {
        newSP->addRelationTo(cluster, cluster->isUCluster() ? 1. : -1.);
 
        RelationVector<MCParticle> relatedMC = cluster->getRelationsTo<MCParticle>();
        RelationVector<SVDTrueHit> relatedSVDTrue = cluster->getRelationsTo<SVDTrueHit>();
 
        // Register relations to the MCParticles and SVDTrueHits
        if (relatedMC.size() > 0) {
          for (unsigned int relmcindex = 0; relmcindex < relatedMC.size(); relmcindex++) {
            newSP->addRelationTo(relatedMC[relmcindex], relatedMC.weight(relmcindex));
          }
        }
        if (relatedSVDTrue.size() > 0) {
          for (unsigned int reltruehitindex = 0; reltruehitindex < relatedSVDTrue.size(); reltruehitindex++) {
            newSP->addRelationTo(relatedSVDTrue[reltruehitindex], relatedSVDTrue.weight(reltruehitindex));
          }
        }
 
      }
 
    }
  }
 
} //Belle2 namespace