Geometry_BDillon/GenerateNStringGCD_Cluster.py at main · pone-software/Geometry_BDillon · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
from icecube import dataio, dataclasses, icetray
from icecube.icetray import OMKey, I3Units
import numpy as np
import argparse
from GenerateLatticeStructure import generateLaticeSpots
import gcdHelpers

parser = argparse.ArgumentParser()
parser.add_argument("-s", "--spacing",type = float, default = 80.0, help="Spacing for strings in cluser.")
parser.add_argument("-l", "--clusterspacing",type = float, default = 400.0, help="Spacing for strings in cluser.")
parser.add_argument("-n", "--nstring",type= int, default = 10, help="Number of strings per cluster.")
parser.add_argument("-c", "--nclusters",type= int, default = 7, help="Number of clusters.")
parser.add_argument("-d", "--ndoms",type= int, default = 20, help="Doms per string.")
parser.add_argument("-r", "--domradius",type= int, default = (17.0*2.54*0.01*0.5), help="Radius of dom. Defaults to 17\"")
parser.add_argument("-p", "--npmts",type= int, default = 16, help="PMTs per DOM.")
args = parser.parse_args()


outfileName = "PONE_"+str(args.nstring)+"String_"+str(args.nclusters)+"Cluster_test8.i3.gz"
outfile = dataio.I3File(outfileName, 'w')
nstrings = args.nstring
spacing = args.spacing
clusterspacing = args.clusterspacing
nclusters = args.nclusters
domsPerString  = args.ndoms

def generateGeometry():
    global Rows
    global domsPerString
    global spacing
    global clusterspacing

    orientation = dataclasses.I3Orientation(0, 0, 1, -1, 0, 0)
    area = 4.0*((args.domradius)**2.0)*np.pi*I3Units.meter2
    geomap = dataclasses.I3OMGeoMap()


    stringposx, stringposy, theta = generateLaticeSpots(nstrings)

    clusterposx, clusterposy, clustertheta = generateLaticeSpots(nclusters)

    clustertheta = [0, np.pi/6, -np.pi/6, np.pi/2, np.pi/6, -np.pi/6, np.pi/2]

    FinalStringx = []
    FinalStringy = []

    for i in range(len(clusterposx)) :
        for j in range(len(stringposx)):
            if i == 0 :
                FinalStringx.append(stringposx[j]*spacing + clusterposx[i]*clusterspacing)
                FinalStringy.append(stringposy[j]*spacing + clusterposy[i]*clusterspacing)
            else :
                FinalStringx.append(np.cos(clustertheta[i])*stringposx[j]*spacing - np.sin(clustertheta[i])*stringposy[j]*spacing + clusterposx[i]*clusterspacing)
                FinalStringy.append(np.sin(clustertheta[i])*stringposx[j]*spacing + np.cos(clustertheta[i])*stringposy[j]*spacing + clusterposy[i]*clusterspacing)

    mean_x = sum(FinalStringx)/len(FinalStringx)
    mean_y = sum(FinalStringy)/len(FinalStringy)

    for i in range(len(FinalStringx)):
        FinalStringx[i] -= mean_x
        FinalStringy[i] -= mean_y

    sp = 950.0/19.0
    depthlist = [(-450.0+sp*i)*I3Units.meter for i in range(20)]
    depth = np.array(depthlist)

    for i in range(len(FinalStringx)) :
        for m in range(domsPerString):
            omGeometry = dataclasses.I3OMGeo()
            omGeometry.omtype = dataclasses.I3OMGeo.OMType.mDOM
            omGeometry.orientation = orientation
            omGeometry.area = area
            omGeometry.position = dataclasses.I3Position(FinalStringx[i], FinalStringy[i], depth[m])
            for j in range(args.npmts) :
                omkey = OMKey(i+1, m+1, j+1)
                geomap[omkey] = omGeometry

    return geomap

geometry = dataclasses.I3Geometry()

geometry.start_time = gcdHelpers.start_time
geometry.end_time = gcdHelpers.end_time
geomap = generateGeometry()
geometry.omgeo = geomap

gframe = icetray.I3Frame(icetray.I3Frame.Geometry)
cframe = gcdHelpers.generateCFrame(geometry)
dframe = gcdHelpers.generateDFrame(geometry)

geomap = generateGeometry()

gframe["I3Geometry"] = geometry
gframe["I3OMGeoMap"] = geomap
modgeomap = dataclasses.I3ModuleGeoMap()
for dom in geomap.keys() :
        mkey = dataclasses.ModuleKey(dom.string,dom.om)
        module = dataclasses.I3ModuleGeo()
        module.module_type = dataclasses.I3ModuleGeo.ModuleType.mDOM
        module.orientation = geomap[dom].orientation
        module.pos = geomap[dom].position
        module.radius = np.sqrt(geomap[dom].area/(4.0*np.pi))
        modgeomap[mkey] = module

gframe["I3ModuleGeoMap"] = modgeomap;
subdetec = dataclasses.I3MapModuleKeyString()
for dom in geomap.keys() :
    mkey = dataclasses.ModuleKey(dom.string,dom.om)
    subdetec[mkey] = "Upgrade"

gframe["Subdetectors"] = subdetec

gframe["StartTime"] = gcdHelpers.start_time
gframe["EndTime"] = gcdHelpers.end_time

outfile.push(gframe)
outfile.push(cframe)
outfile.push(dframe)

outfile.close()