KLMDisplacementGenerator Class Reference

Module for generation of KLM displacement or alignment data. More...

#include <KLMDisplacementGenerator.h>

Public Member Functions
	KLMDisplacementGenerator ()
	Constructor.
	~KLMDisplacementGenerator ()
	Destructor.
void	fillZeroDisplacements (EKLMAlignment *alignment, EKLMSegmentAlignment *segmentAlignment)
	Fill EKLMAlignment with zero displacements.
void	generateFixedModuleDisplacement (double deltaU, double deltaV, double deltaGamma)
	Generation of fixed module displacements.
void	generateRandomDisplacement (EKLMAlignment *alignment, EKLMSegmentAlignment *segmentAlignment, bool displaceModule, bool displaceSegment, bool moduleSameDisplacement=false, bool moduleZeroDeltaU=false, bool moduleZeroDeltaV=false, bool moduleZeroDeltaGamma=false)
	Generation of random displacements.
void	readDisplacementFromROOTFile (EKLMAlignment *alignment, EKLMSegmentAlignment *segmentAlignment, const char *inputFile)
	Read displacement from ROOT file.
void	studyModuleAlignmentLimits (TFile *f)
	Generate random module displacements and check if they are correct (no overlaps).
void	studySegmentAlignmentLimits (TFile *f)
	Generate random segment displacements and check if they are correct (no overlaps).
void	studyAlignmentLimits (const char *outputFile)
	Generate random displacements and check if they are correct (no overlaps).
void	saveDisplacement (EKLMAlignment *alignment, EKLMSegmentAlignment *segmentAlignment, const char *outputFile)
	Save displacements to a ROOT file.

Private Attributes
const EKLM::GeometryData *	m_GeoDat
	Geometry data.
const KLMElementNumbers *	m_ElementNumbers
	Element numbers.
const EKLMElementNumbers *	m_eklmElementNumbers
	EKLM element numbers.

Detailed Description

Module for generation of KLM displacement or alignment data.

Definition at line 30 of file KLMDisplacementGenerator.h.

Constructor & Destructor Documentation

KLMDisplacementGenerator()

KLMDisplacementGenerator

(

)

Constructor.

Definition at line 26 of file KLMDisplacementGenerator.cc.

                                                   :
  m_GeoDat(&(EKLM::GeometryData::Instance())),
  m_ElementNumbers(&(KLMElementNumbers::Instance())),
  m_eklmElementNumbers(&(EKLMElementNumbers::Instance()))
{
}

~KLMDisplacementGenerator()

~KLMDisplacementGenerator

(

)

Destructor.

Definition at line 33 of file KLMDisplacementGenerator.cc.

{
}

Member Function Documentation

fillZeroDisplacements()

void fillZeroDisplacements	(	EKLMAlignment *	alignment,
		EKLMSegmentAlignment *	segmentAlignment
	)

Fill EKLMAlignment with zero displacements.

Parameters

[out]	alignment	Displacements.
[out]	segmentAlignment	Segment displacements.

Definition at line 37 of file KLMDisplacementGenerator.cc.

{
  KLMAlignmentData alignmentData(0, 0, 0, 0, 0, 0);
  int iSection, iLayer, iSector, iPlane, iSegment, segment;
  for (iSection = 1; iSection <= m_GeoDat->getNSections(); iSection++) {
    for (iLayer = 1; iLayer <= m_GeoDat->getNDetectorLayers(iSection);
         iLayer++) {
      for (iSector = 1; iSector <= m_GeoDat->getNSectors(); iSector++) {
        int module = m_ElementNumbers->moduleNumberEKLM(iSection, iSector, iLayer);
        alignment->setModuleAlignment(module, &alignmentData);
        for (iPlane = 1; iPlane <= m_GeoDat->getNPlanes(); iPlane++) {
          for (iSegment = 1; iSegment <= m_GeoDat->getNSegments(); iSegment++) {
            segment = m_eklmElementNumbers->segmentNumber(
                        iSection, iLayer, iSector, iPlane, iSegment);
            segmentAlignment->setSegmentAlignment(segment, &alignmentData);
          }
        }
      }
    }
  }
}

generateFixedModuleDisplacement()

void generateFixedModuleDisplacement	(	double	deltaU,
		double	deltaV,
		double	deltaGamma
	)

Generation of fixed module displacements.

Parameters

[in]	deltaU	Shift in U.
[in]	deltaV	Shift in V.
[in]	deltaGamma	Rotation in Gamma.

Definition at line 60 of file KLMDisplacementGenerator.cc.

{
  EKLMAlignment alignment;
  EKLMSegmentAlignment segmentAlignment;
  KLMAlignmentData moduleAlignment(deltaU, deltaV, 0, 0, 0, deltaGamma);
  int iSection, iLayer, iSector;
  fillZeroDisplacements(&alignment, &segmentAlignment);
  for (iSection = 1; iSection <= m_GeoDat->getNSections(); iSection++) {
    for (iLayer = 1; iLayer <= m_GeoDat->getNDetectorLayers(iSection);
         iLayer++) {
      for (iSector = 1; iSector <= m_GeoDat->getNSectors(); iSector++) {
        int module = m_ElementNumbers->moduleNumberEKLM(iSection, iSector, iLayer);
        alignment.setModuleAlignment(module, &moduleAlignment);
      }
    }
  }
}

generateRandomDisplacement()

void generateRandomDisplacement	(	EKLMAlignment *	alignment,
		EKLMSegmentAlignment *	segmentAlignment,
		bool	displaceModule,
		bool	displaceSegment,
		bool	moduleSameDisplacement = false,
		bool	moduleZeroDeltaU = false,
		bool	moduleZeroDeltaV = false,
		bool	moduleZeroDeltaGamma = false
	)

Generation of random displacements.

Parameters

[out]	alignment	Displacements.
[out]	segmentAlignment	Segment displacements.
[in]	displaceModule	Whether modules should be displaced.
[in]	displaceSegment	Whether segments should be displaced.
[in]	moduleSameDisplacement	If the displacement should be the same for all modules.
[in]	moduleZeroDeltaU	Fix module deltaU at 0.
[in]	moduleZeroDeltaV	Fix module deltaV at 0.
[in]	moduleZeroDeltaGamma	Fix module deltaGamma at 0.

Definition at line 79 of file KLMDisplacementGenerator.cc.

{
  const double moduleMaxDeltaU = 5. * Unit::cm;
  const double moduleMinDeltaU = -5. * Unit::cm;
  const double moduleMaxDeltaV = 5. * Unit::cm;
  const double moduleMinDeltaV = -5. * Unit::cm;
  const double moduleMaxDeltaGamma = 0.02 * Unit::rad;
  const double moduleMinDeltaGamma = -0.02 * Unit::rad;
  const double segmentMaxDeltaU = 1. * Unit::cm;
  const double segmentMinDeltaU = -1. * Unit::cm;
  const double segmentMaxDeltaV = 0.2 * Unit::cm;
  const double segmentMinDeltaV = -0.2 * Unit::cm;
  const double segmentMaxDeltaGamma = 0.003 * Unit::rad;
  const double segmentMinDeltaGamma = -0.003 * Unit::rad;
  KLMAlignmentData moduleAlignmentData, segmentAlignmentData, *alignmentData;
  EKLM::AlignmentChecker alignmentChecker(false);
  int iSection, iLayer, iSector, iPlane, iSegment, segment;
  double d;
  fillZeroDisplacements(alignment, segmentAlignment);
  for (iSection = 1; iSection <= m_GeoDat->getNSections(); iSection++) {
    for (iLayer = 1; iLayer <= m_GeoDat->getNDetectorLayers(iSection);
         iLayer++) {
      for (iSector = 1; iSector <= m_GeoDat->getNSectors(); iSector++) {
        if (moduleSameDisplacement) {
          if (iSection > 1 || iLayer > 1 || iSector > 1) {
            int module = m_ElementNumbers->moduleNumberEKLM(1, 1, 1);
            alignmentData = const_cast<KLMAlignmentData*>(
                              alignment->getModuleAlignment(module));
            module = m_ElementNumbers->moduleNumberEKLM(iSection, iSector, iLayer);
            alignment->setModuleAlignment(module, alignmentData);
            for (iPlane = 1; iPlane <= m_GeoDat->getNPlanes(); iPlane++) {
              for (iSegment = 1; iSegment <= m_GeoDat->getNSegments();
                   iSegment++) {
                segment = m_eklmElementNumbers->segmentNumber(1, 1, 1, iPlane, iSegment);
                alignmentData = const_cast<KLMAlignmentData*>(
                                  segmentAlignment->getSegmentAlignment(segment));
                segment = m_eklmElementNumbers->segmentNumber(
                            iSection, iLayer, iSector, iPlane, iSegment);
                segmentAlignment->setSegmentAlignment(segment, alignmentData);
              }
            }
            continue;
          }
        }
module:
        if (displaceModule) {
          do {
            if (moduleZeroDeltaU)
              d = 0;
            else
              d = gRandom->Uniform(moduleMinDeltaU, moduleMaxDeltaU);
            moduleAlignmentData.setDeltaU(d);
            if (moduleZeroDeltaV)
              d = 0;
            else
              d = gRandom->Uniform(moduleMinDeltaV, moduleMaxDeltaV);
            moduleAlignmentData.setDeltaV(d);
            if (moduleZeroDeltaGamma)
              d = 0;
            else
              d = gRandom->Uniform(moduleMinDeltaGamma, moduleMaxDeltaGamma);
            moduleAlignmentData.setDeltaGamma(d);
          } while (!alignmentChecker.checkSectorAlignment(
                     iSection, iLayer, iSector, &moduleAlignmentData));
          int module = m_ElementNumbers->moduleNumberEKLM(iSection, iSector, iLayer);
          alignment->setModuleAlignment(module, &moduleAlignmentData);
        }
        if (displaceSegment) {
          for (iPlane = 1; iPlane <= m_GeoDat->getNPlanes(); iPlane++) {
            for (iSegment = 1; iSegment <= m_GeoDat->getNSegments();
                 iSegment++) {
              do {
                segmentAlignmentData.setDeltaU(
                  gRandom->Uniform(segmentMinDeltaU, segmentMaxDeltaU));
                segmentAlignmentData.setDeltaV(
                  gRandom->Uniform(segmentMinDeltaV, segmentMaxDeltaV));
                segmentAlignmentData.setDeltaGamma(
                  gRandom->Uniform(segmentMinDeltaGamma, segmentMaxDeltaGamma));
              } while (!alignmentChecker.checkSegmentAlignment(
                         iSection, iLayer, iSector, iPlane, iSegment,
                         &moduleAlignmentData, &segmentAlignmentData, false));
              segment = m_eklmElementNumbers->segmentNumber(
                          iSection, iLayer, iSector, iPlane, iSegment);
              segmentAlignment->setSegmentAlignment(
                segment, &segmentAlignmentData);
            }
          }
        } else {
          for (iPlane = 1; iPlane <= m_GeoDat->getNPlanes(); iPlane++) {
            for (iSegment = 1; iSegment <= m_GeoDat->getNSegments();
                 iSegment++) {
              if (!alignmentChecker.checkSegmentAlignment(
                    iSection, iLayer, iSector, iPlane, iSegment,
                    &moduleAlignmentData, &segmentAlignmentData, false))
                goto module;
            }
          }
        }
      }
    }
  }
}

readDisplacementFromROOTFile()

void readDisplacementFromROOTFile	(	EKLMAlignment *	alignment,
		EKLMSegmentAlignment *	segmentAlignment,
		const char *	inputFile
	)

Read displacement from ROOT file.

Parameters

[out]	alignment	Displacements.
[out]	segmentAlignment	Segment displacements.
[in]	inputFile	Input file.

Definition at line 185 of file KLMDisplacementGenerator.cc.

{
  /* cppcheck-suppress variableScope */
  int i, n, iSection, iLayer, iSector, iPlane, iSegment, segment, param;
  float value;
  TFile* f;
  TTree* tEKLMModule, *tEKLMSegment;
  KLMAlignmentData* alignmentData;
  fillZeroDisplacements(alignment, segmentAlignment);
  f = new TFile(inputFile);
  tEKLMModule = (TTree*)f->Get("eklm_module");
  tEKLMModule->SetBranchAddress("section", &iSection);
  tEKLMModule->SetBranchAddress("layer", &iLayer);
  tEKLMModule->SetBranchAddress("sector", &iSector);
  tEKLMModule->SetBranchAddress("param", &param);
  tEKLMModule->SetBranchAddress("value", &value);
  tEKLMSegment = (TTree*)f->Get("eklm_segment");
  tEKLMSegment->SetBranchAddress("section", &iSection);
  tEKLMSegment->SetBranchAddress("layer", &iLayer);
  tEKLMSegment->SetBranchAddress("sector", &iSector);
  tEKLMSegment->SetBranchAddress("plane", &iPlane);
  tEKLMSegment->SetBranchAddress("segment", &iSegment);
  tEKLMSegment->SetBranchAddress("param", &param);
  tEKLMSegment->SetBranchAddress("value", &value);
  n = tEKLMModule->GetEntries();
  for (i = 0; i < n; i++) {
    tEKLMModule->GetEntry(i);
    int module = m_ElementNumbers->moduleNumberEKLM(iSection, iSector, iLayer);
    alignmentData = const_cast<KLMAlignmentData*>(
                      alignment->getModuleAlignment(module));
    switch (param) {
      case 1:
        alignmentData->setDeltaU(value);
        break;
      case 2:
        alignmentData->setDeltaV(value);
        break;
      case 3:
        alignmentData->setDeltaGamma(value);
        break;
    }
  }
  n = tEKLMSegment->GetEntries();
  for (i = 0; i < n; i++) {
    tEKLMSegment->GetEntry(i);
    segment = m_eklmElementNumbers->segmentNumber(
                iSection, iLayer, iSector, iPlane, iSegment);
    alignmentData = const_cast<KLMAlignmentData*>(
                      segmentAlignment->getSegmentAlignment(segment));
    switch (param) {
      case 1:
        alignmentData->setDeltaV(value);
        break;
      case 2:
        alignmentData->setDeltaGamma(value);
        break;
    }
  }
}

saveDisplacement()

void saveDisplacement	(	EKLMAlignment *	alignment,
		EKLMSegmentAlignment *	segmentAlignment,
		const char *	outputFile
	)

Save displacements to a ROOT file.

Parameters

[in]	alignment	Displacements.
[in]	segmentAlignment	Segment displacements.
[in]	outputFile	Output file.

Definition at line 363 of file KLMDisplacementGenerator.cc.

{
  int iSection, iLayer, iSector, iPlane, iSegment, segment, param;
  float value;
  KLMAlignmentData* alignmentData;
  TFile* f;
  TTree* tEKLMModule, *tEKLMSegment;
  f = new TFile(outputFile, "recreate");
  tEKLMModule = new TTree("eklm_module", "");
  tEKLMModule->Branch("section", &iSection, "section/I");
  tEKLMModule->Branch("layer", &iLayer, "layer/I");
  tEKLMModule->Branch("sector", &iSector, "sector/I");
  tEKLMModule->Branch("param", &param, "param/I");
  tEKLMModule->Branch("value", &value, "value/F");
  tEKLMSegment = new TTree("eklm_segment", "");
  tEKLMSegment->Branch("section", &iSection, "section/I");
  tEKLMSegment->Branch("layer", &iLayer, "layer/I");
  tEKLMSegment->Branch("sector", &iSector, "sector/I");
  tEKLMSegment->Branch("plane", &iPlane, "plane/I");
  tEKLMSegment->Branch("segment", &iSegment, "segment/I");
  tEKLMSegment->Branch("param", &param, "param/I");
  tEKLMSegment->Branch("value", &value, "value/F");
  for (iSection = 1; iSection <= m_GeoDat->getNSections(); iSection++) {
    for (iLayer = 1; iLayer <= m_GeoDat->getNDetectorLayers(iSection);
         iLayer++) {
      for (iSector = 1; iSector <= m_GeoDat->getNSectors(); iSector++) {
        int module = m_ElementNumbers->moduleNumberEKLM(iSection, iSector, iLayer);
        alignmentData = const_cast<KLMAlignmentData*>(
                          alignment->getModuleAlignment(module));
        param = 1;
        value = alignmentData->getDeltaU();
        tEKLMModule->Fill();
        /* cppcheck-suppress redundantAssignment */
        param = 2;
        /* cppcheck-suppress redundantAssignment */
        value = alignmentData->getDeltaV();
        tEKLMModule->Fill();
        /* cppcheck-suppress redundantAssignment */
        param = 6;
        /* cppcheck-suppress redundantAssignment */
        value = alignmentData->getDeltaGamma();
        tEKLMModule->Fill();
        for (iPlane = 1; iPlane <= m_GeoDat->getNPlanes(); iPlane++) {
          for (iSegment = 1; iSegment <= m_GeoDat->getNSegments(); iSegment++) {
            segment = m_eklmElementNumbers->segmentNumber(
                        iSection, iLayer, iSector, iPlane, iSegment);
            alignmentData = const_cast<KLMAlignmentData*>(
                              segmentAlignment->getSegmentAlignment(segment));
            param = 2;
            value = alignmentData->getDeltaV();
            tEKLMSegment->Fill();
            /* cppcheck-suppress redundantAssignment */
            param = 6;
            /* cppcheck-suppress redundantAssignment */
            value = alignmentData->getDeltaGamma();
            tEKLMSegment->Fill();
          }
        }
      }
    }
  }
  f->cd();
  tEKLMModule->Write();
  tEKLMSegment->Write();
  delete tEKLMModule;
  delete tEKLMSegment;
  delete f;
}

studyAlignmentLimits()

void studyAlignmentLimits

(

const char *

outputFile

)

Generate random displacements and check if they are correct (no overlaps).

Parameters

[in]

outputFile

Output file.

Definition at line 354 of file KLMDisplacementGenerator.cc.

{
  TFile* f;
  f = new TFile(outputFile, "recreate");
  studyModuleAlignmentLimits(f);
  studySegmentAlignmentLimits(f);
  delete f;
}

studyModuleAlignmentLimits()

void studyModuleAlignmentLimits

(

TFile *

f

)

Generate random module displacements and check if they are correct (no overlaps).

Parameters

[in]

f

Output file.

Definition at line 247 of file KLMDisplacementGenerator.cc.

{
  const int nPoints = 1000;
  const float maxDeltaU = 5. * Unit::cm;
  const float minDeltaU = -5. * Unit::cm;
  const float maxDeltaV = 5. * Unit::cm;
  const float minDeltaV = -5. * Unit::cm;
  const float maxDeltaGamma = 0.02 * Unit::rad;
  const float minDeltaGamma = -0.02 * Unit::rad;
  float deltaU, deltaV, deltaGamma;
  int i, alignmentStatus, iSection, iLayer, iSector;
  EKLMAlignment alignment;
  EKLMSegmentAlignment segmentAlignment;
  KLMAlignmentData alignmentDataRandom;
  EKLM::AlignmentChecker alignmentChecker(false);
  TTree* t;
  f->cd();
  t = new TTree("module", "");
  t->Branch("deltaU", &deltaU, "deltaU/F");
  t->Branch("deltaV", &deltaV, "deltaV/F");
  t->Branch("deltaGamma", &deltaGamma, "deltaGamma/F");
  t->Branch("status", &alignmentStatus, "status/I");
  for (i = 0; i < nPoints; i++) {
    fillZeroDisplacements(&alignment, &segmentAlignment);
    deltaU = gRandom->Uniform(minDeltaU, maxDeltaU);
    deltaV = gRandom->Uniform(minDeltaV, maxDeltaV);
    deltaGamma = gRandom->Uniform(minDeltaGamma, maxDeltaGamma);
    alignmentDataRandom.setDeltaU(deltaU);
    alignmentDataRandom.setDeltaV(deltaV);
    alignmentDataRandom.setDeltaGamma(deltaGamma);
    for (iSection = 1; iSection <= m_GeoDat->getNSections(); iSection++) {
      for (iLayer = 1; iLayer <= m_GeoDat->getNDetectorLayers(iSection);
           iLayer++) {
        for (iSector = 1; iSector <= m_GeoDat->getNSectors(); iSector++) {
          int module = m_ElementNumbers->moduleNumberEKLM(iSection, iSector, iLayer);
          alignment.setModuleAlignment(module, &alignmentDataRandom);
        }
      }
    }
    if (alignmentChecker.checkAlignment(&alignment, &segmentAlignment))
      alignmentStatus = 1;
    else
      alignmentStatus = 0;
    t->Fill();
  }
  t->Write();
}

studySegmentAlignmentLimits()

void studySegmentAlignmentLimits

(

TFile *

f

)

Generate random segment displacements and check if they are correct (no overlaps).

Parameters

[in]

f

Output file.

Definition at line 295 of file KLMDisplacementGenerator.cc.

{
  const int nPoints = 1000;
  const float maxDeltaU = 9. * Unit::cm;
  const float minDeltaU = -4. * Unit::cm;
  const float maxDeltaV = 0.2 * Unit::cm;
  const float minDeltaV = -0.2 * Unit::cm;
  const float maxDeltaGamma = 0.003 * Unit::rad;
  const float minDeltaGamma = -0.003 * Unit::rad;
  float deltaU, deltaV, deltaGamma;
  int i, alignmentStatus;
  int iSection, iLayer, iSector, jPlane, jSegment, segment;
  EKLMAlignment alignment;
  EKLMSegmentAlignment segmentAlignment;
  KLMAlignmentData alignmentDataRandom;
  EKLM::AlignmentChecker alignmentChecker(false);
  TTree* t;
  f->cd();
  t = new TTree("segment", "");
  t->Branch("plane", &jPlane, "plane/I");
  t->Branch("segment", &jSegment, "segment/I");
  t->Branch("deltaU", &deltaU, "deltaU/F");
  t->Branch("deltaV", &deltaV, "deltaV/F");
  t->Branch("deltaGamma", &deltaGamma, "deltaGamma/F");
  t->Branch("status", &alignmentStatus, "status/I");
  for (jPlane = 1; jPlane <= m_GeoDat->getNPlanes(); jPlane++) {
    printf("Plane %d\n", jPlane);
    for (jSegment = 1; jSegment <= m_GeoDat->getNSegments(); jSegment++) {
      printf("Segment %d\n", jSegment);
      for (i = 0; i < nPoints; i++) {
        fillZeroDisplacements(&alignment, &segmentAlignment);
        deltaU = gRandom->Uniform(minDeltaU, maxDeltaU);
        deltaV = gRandom->Uniform(minDeltaV, maxDeltaV);
        deltaGamma = gRandom->Uniform(minDeltaGamma, maxDeltaGamma);
        alignmentDataRandom.setDeltaU(deltaU);
        alignmentDataRandom.setDeltaV(deltaV);
        alignmentDataRandom.setDeltaGamma(deltaGamma);
        for (iSection = 1; iSection <= m_GeoDat->getNSections(); iSection++) {
          for (iLayer = 1; iLayer <= m_GeoDat->getNDetectorLayers(iSection);
               iLayer++) {
            for (iSector = 1; iSector <= m_GeoDat->getNSectors(); iSector++) {
              segment = m_eklmElementNumbers->segmentNumber(
                          iSection, iLayer, iSector, jPlane, jSegment);
              segmentAlignment.setSegmentAlignment(
                segment, &alignmentDataRandom);
            }
          }
        }
        if (alignmentChecker.checkAlignment(&alignment, &segmentAlignment))
          alignmentStatus = 1;
        else
          alignmentStatus = 0;
        t->Fill();
      }
    }
  }
  t->Write();
}

Member Data Documentation

m_eklmElementNumbers

const EKLMElementNumbers* m_eklmElementNumbers

private

EKLM element numbers.

Definition at line 144 of file KLMDisplacementGenerator.h.

m_ElementNumbers

const KLMElementNumbers* m_ElementNumbers

private

Element numbers.

Definition at line 141 of file KLMDisplacementGenerator.h.

m_GeoDat

const EKLM::GeometryData* m_GeoDat

private

Geometry data.

Definition at line 138 of file KLMDisplacementGenerator.h.

---

The documentation for this class was generated from the following files:

• klm/calibration/include/KLMDisplacementGenerator.h
• klm/calibration/src/KLMDisplacementGenerator.cc