CreateMisalignmentModule Class Reference

Inheritance diagram for CreateMisalignmentModule:

Public Member Functions
	__init__ (self, global_deformations=None, random_misalignments=None, iov=Belle2.IntervalOfValidity(0, 0, -1, -1))
	initialize (self)

Public Attributes
	global_deformations = global_deformations
	systematic deformations
list	random_misalignments = random_misalignments
	random misalignments
	iov = iov
	interval of validity for the generated payload

Detailed Description

 Module to create misalignment (first reads real sensor positions, then applies misalignment and returns DB payload)
    TODO: random misalignment not finished...

Definition at line 185 of file misalignment.py.

Constructor & Destructor Documentation

__init__()

__init__	(		self,
			global_deformations = None,
			random_misalignments = None,
			iov = Belle2.IntervalOfValidity(0, 0, -1, -1) )

 Constructor with with input misalignment 

Definition at line 190 of file misalignment.py.

    def __init__(self, global_deformations=None, random_misalignments=None, iov=Belle2.IntervalOfValidity(0, 0, -1, -1)):
        """ Constructor with with input misalignment """
 
        
        self.global_deformations = global_deformations
        
        self.random_misalignments = random_misalignments
        
        self.iov = iov
 
        super().__init__()
 

Member Function Documentation

initialize()

initialize

(

self

)

 module initialize - read geometry, apply misalignment, create and store payloads 

Definition at line 202 of file misalignment.py.

    def initialize(self):
        """ module initialize - read geometry, apply misalignment, create and store payloads """
 
        alignment = Belle2.VXDAlignment()
        txt = open('generated_misalignment.txt', 'w')
        txt.write('layer ladder sensor x_orig y_orig z_orig x y z u v w\n')
 
        for sensor in Belle2.VXD.GeoCache.getInstance().getListOfSensors():
            info = Belle2.VXD.GeoCache.getInstance().get(sensor)
            global_pos = info.pointToGlobal(ROOT.TVector3(0., 0., 0.))
 
            delta = ROOT.TVector3(0., 0., 0.)
 
            global_deformations = self.global_deformations
            if global_deformations is not None:
                if not isinstance(global_deformations, list):
                    global_deformations = [global_deformations]
                    self.global_deformations = global_deformations
 
                for deformation in global_deformations:
                    delta += deformation(global_pos)
 
            if sensor == Belle2.VxdID(1, 1, 1):
                delta = ROOT.TVector3(0., 0., 0.)
 
            new_global_pos = global_pos + delta
            new_local_pos = info.pointToLocal(new_global_pos)
 
            if self.random_misalignments is not None:
                if not isinstance(self.random_misalignments, list):
                    self.random_misalignments = [self.random_misalignments]
 
                for random in self.random_misalignments:
                    pass
 
            for i in range(0, 3):
                if abs(new_local_pos[i]) < 1.e-14:
                    new_local_pos[i] = 0.
 
                alignment.set(sensor.getID(), i + 1, new_local_pos[i])
 
            # helper = GlobalDeformation(0.)
 
            # global_pos = helper._xyz_to_rphiz(global_pos)
            # new_global_pos = helper._xyz_to_rphiz(new_global_pos)
 
            txt.write(
                '{} {} {} {} {} {} {} {} {} {} {} {}\n'.format(
                    str(sensor.getLayerNumber()),
                    str(sensor.getLadderNumber()),
                    str(sensor.getSensorNumber()),
                    str(global_pos[0]),
                    str(global_pos[1]),
                    str(global_pos[2]),
                    str(new_global_pos[0]),
                    str(new_global_pos[1]),
                    str(new_global_pos[2]),
                    str(new_local_pos[0]),
                    str(new_local_pos[1]),
                    str(new_local_pos[2])
                ))
 
        txt.close()
 
        Belle2.Database.Instance().storeData('VXDAlignment', alignment, self.iov)
        txt.close()

Member Data Documentation

global_deformations

global_deformations = global_deformations

systematic deformations

Definition at line 194 of file misalignment.py.

iov

iov = iov

interval of validity for the generated payload

Definition at line 198 of file misalignment.py.

random_misalignments

random_misalignments = random_misalignments

random misalignments

Definition at line 196 of file misalignment.py.

---

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

• alignment/scripts/alignment/misalignment.py