from heptools.collider import delphes
@delphes.activate
def photon(i, photons):
if i > 1000:
delphes.deactivate(photon)
for p1, p2 in itertools.combinations(photons, 2):
do_something()
delphes.load_root_file(SOME_ROOT_FILE)
'''
from ROOT import gSystem
gSystem.Load('libDelphes')
from ROOT import TChain, ExRootTreeReader
import inspect
DELPHES_BRANCH = 'Delphes'
delphes_name = [
'Event', 'Particle', 'Track', 'Tower', 'EFlowTrack', 'EFlowPhoton',
'EFlowNeutralHadron', 'GenJet', 'Jet', 'Electron', 'Photon', 'Muon',
'MissingET', 'ScalarHT'
]
callback_functions = {}
gStyle.SetOptStat(000000)
gStyle.SetOptTitle(0);
gStyle.SetTitleFont(43)
gStyle.SetTitleFont(43, "XYZ")
gStyle.SetTitleSize(30, "XYZ")
gStyle.SetLabelFont(43, "XYZ")
gStyle.SetLabelSize(24, "XYZ")
gStyle.SetPadTopMargin(0.07);
gStyle.SetPadRightMargin(0.05);
gStyle.SetPadBottomMargin(0.16);
gStyle.SetPadLeftMargin(0.18);
gSystem.Load("RooUnfold/libRooUnfold.so")
from ROOT import RooUnfoldResponse
from ROOT import RooUnfold
from ROOT import RooUnfoldBayes
from ROOT import RooUnfoldSvd
# -------------------------------------------------------------------------------------
# cross sections, efficiencies, total number of events
# -------------------------------------------------------------------------------------
lum = 12337.98 # was 12358.75 (pb-1), but missing some data
if options.lepType == "ele":
lum = 12267.67 # was 12295.65 (pb-1), but missing some data
pfreconstruct.detector = clic
from heppy.analyzers.PDebugger import PDebugger
pdebug = cfg.Analyzer(
PDebugger,
output_to_stdout=False, #optional
debug_filename=None #No output
)
# definition of a sequence of analyzers,
# the analyzers will process each event in this order
sequence = cfg.Sequence(
source,
pdebug,
# gen_particles_stable,
papas_sequence,
sum_particles,
sum_gen,
zed_tree,
display)
# Specifics to read FCC events
from ROOT import gSystem
gSystem.Load("libdatamodelDict")
from EventStore import EventStore as Events
config = cfg.Config(components=selectedComponents,
sequence=sequence,
services=[],
events_class=Events)
import sys
if len(sys.argv) < 2:
msg = '\n'
msg += "Usage 1: %s $INPUT_ROOT_FILE\n" % sys.argv[0]
msg += '\n'
sys.stderr.write(msg)
sys.exit(1)
from ROOT import larlite as fmwk
from ROOT import gSystem
gSystem.Load('libKalekoAna_LArSoftImport')
# Create ana_processor instance
my_proc = fmwk.ana_processor()
# Set input root file
for x in xrange(len(sys.argv)):
if x == 0: continue
my_proc.add_input_file(sys.argv[x])
# Specify IO mode
my_proc.set_io_mode(fmwk.storage_manager.kREAD)
# Specify output root file name
my_proc.set_ana_output_file("testmultiscatterpid_output.root");
# Attach a template process
my_proc.add_process(fmwk.TestMultiScatterPID());
print
print "TTree entries: ", entries
print "Compiling...."
#Some system have problem runnig compilation (missing glibc-static library?).
#First we try to compile, and only then we start time consuming cmssw
assert gSystem.CompileMacro('HTTEvent.cxx', 'k')
assert gSystem.CompileMacro('utils/TauTriggerSFs2017/src/TauTriggerSFs2017.cc',
'k')
assert gSystem.CompileMacro('HTXSClassification.cc', 'k')
assert gSystem.CompileMacro('EventWriter.C', 'k')
#status *= gSystem.CompileMacro('NanoEventsSkeleton.C') #RECOMPILE IF IT CHANGES!
assert gSystem.CompileMacro('NanoEventsSkeleton.C', 'k')
gSystem.Load('$CMSSW_BASE/lib/$SCRAM_ARCH/libTauAnalysisClassicSVfit.so')
gSystem.Load('$CMSSW_BASE/lib/$SCRAM_ARCH/libTauAnalysisSVfitTF.so')
gSystem.Load(
'$CMSSW_BASE/lib/$SCRAM_ARCH/libHTT-utilitiesRecoilCorrections.so')
assert gSystem.CompileMacro('HTauTauTreeFromNanoBase.C', 'k')
from ROOT import HTTParticle, HTTAnalysis
if channel == 'mt':
assert gSystem.CompileMacro('HMuTauhTreeFromNano.C', 'k')
from ROOT import HMuTauhTreeFromNano as Ntuplizer
if channel == 'et':
assert gSystem.CompileMacro('HElTauhTreeFromNano.C', 'k')
from ROOT import HElTauhTreeFromNano as Ntuplizer
import os
import sys
import math as m
import numpy as n
import ROOT as r
import os.path
import os
from scipy.signal import argrelextrema, savgol_filter, find_peaks_cwt, argrelmax
from ROOT import gSystem
result = gSystem.Load("libDDCorePlugins")
from ROOT import dd4hep
if result < 0:
print "No lib loadable!"
system_decoder = dd4hep.DDSegmentation.BitFieldCoder("system:4")
ecalBarrel_decoder = dd4hep.DDSegmentation.BitFieldCoder(
"system:4,cryo:1,type:3,subtype:3,layer:8,eta:11,phi:10")
hcalBarrel_decoder = dd4hep.DDSegmentation.BitFieldCoder(
"system:4,module:8,row:9,layer:5")
hcalExtBarrel_decoder = dd4hep.DDSegmentation.BitFieldCoder(
"system:4,module:8,row:9,layer:5")
ecalEndcap_decoder = dd4hep.DDSegmentation.BitFieldCoder(
"system:4,subsystem:1,type:3,subtype:3,layer:8,eta:10,phi:10")
hcalEndcap_decoder = dd4hep.DDSegmentation.BitFieldCoder(
"system:4,subsystem:1,type:3,subtype:3,layer:8,eta:10,phi:10")
ecalFwd_decoder = dd4hep.DDSegmentation.BitFieldCoder(
"system:4,subsystem:1,type:3,subtype:3,layer:8,eta:11,phi:10")
hcalFwd_decoder = dd4hep.DDSegmentation.BitFieldCoder(
"system:4,subsystem:1,type:3,subtype:3,layer:8,eta:11,phi:10")
trackerBarrel_decoder = dd4hep.DDSegmentation.BitFieldCoder(
def loadModule( name ):
stat = gSystem.Load( name )
if stat < 0:
__log.error( 'could not load [' + name + ']' )
raise RuntimeError
from ROOT import gSystem
import os, logging, platform
if platform.system() == "Darwin":
gSystem.SetDynamicPath(os.environ['DD4HEP_LIBRARY_PATH'])
gSystem.Load('libDDPython')
from ROOT import dd4hep as Core
logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.DEBUG)
name_space = __import__(__name__)
def import_namespace_item(ns, nam):
scope = getattr(name_space, ns)
attr = getattr(scope, nam)
setattr(name_space, nam, attr)
return attr
def a_func():
logging.info('Hello world')
return 1
class a_class:
def __init__(self):
pass
def fcn(self):
logging.info('Hello world from member function fcn')
'''
Created on 31 Oct 2012
@author: kreczko
'''
from ROOT import gSystem, cout, TDecompSVD
import config.RooUnfold as unfoldCfg
from tools.hist_utilities import hist_to_value_error_tuplelist, fix_overflow
gSystem.Load( unfoldCfg.library )
from ROOT import RooUnfoldResponse, RooUnfoldParms, RooUnfold, RooUnfoldBayes, RooUnfoldSvd
from ROOT import RooUnfoldBinByBin, RooUnfoldInvert, RooUnfoldTUnfold
from ROOT import TSVDUnfold
from ROOT import TH2D, TH1D
from rootpy import asrootpy
from rootpy.plotting import Hist, Hist2D
from math import sqrt
class Unfolding:
def __init__( self,
truth,
measured,
response,
fakes = None,
method = 'RooUnfoldSvd',
tau = unfoldCfg.SVD_tau_value,
k_value = unfoldCfg.SVD_k_value,
n_toy = unfoldCfg.SVD_n_toy,
Bayes_n_repeat = unfoldCfg.Bayes_n_repeat,
error_treatment = unfoldCfg.error_treatment,
measured_truth_without_fakes = None,
import math
import re
import ROOT
from ROOT import gSystem
from PhysicsTools.Heppy.analyzers.core.Analyzer import Analyzer
from PhysicsTools.Heppy.analyzers.core.AutoHandle import AutoHandle
from PhysicsTools.Heppy.physicsobjects.Jet import Jet
from PhysicsTools.HeppyCore.utils.deltar import cleanObjectCollection
gSystem.Load("libCMGToolsH2TauTau")
from ROOT import HTTRecoilCorrector as RC
LorentzVector = ROOT.Math.LorentzVector(ROOT.Math.PxPyPzE4D("double"))
def get_final_ptcs(ptc):
if ptc.numberOfDaughters() == 0:
return [ptc]
else:
final_ptcs = []
for i_daughter in range(ptc.numberOfDaughters()):
l = get_final_ptcs(ptc.daughter(i_daughter))
final_ptcs += l
return final_ptcs
import sys
from ROOT import gSystem
gSystem.Load("libKazuAna_Boke")
from ROOT import sample
try:
print "PyROOT recognized your class %s" % str(sample)
except NameError:
print "Failed importing Boke..."
sys.exit(0)
#
# Example PyROOT script to run analysis module, ana_base.
# The usage is same for inherited analysis class instance.
#
# Load libraries
import os, ROOT, sys
from ROOT import gSystem
gSystem.Load("libAnalysis")
gSystem.Load("libLArUtil")
gSystem.Load("libDavidAna")
# Now import ana_processor & your class. For this example, ana_base.
from ROOT import larlight as fmwk
infilename = sys.argv[1]
outfilename = "hits.root"
# Create ana_processor instance
my_proc = fmwk.ana_processor()
# Specify IO mode
my_proc.set_io_mode(fmwk.storage_manager.BOTH)
#my_proc.set_io_mode(storage_manager.WRITE)
#my_proc.set_io_mode(fmwk.storage_manager.BOTH)
# Specify what data to read
my_proc.set_data_to_read(fmwk.DATA.TPCFIFO)
#my_proc.set_data_to_read(fmwk.DATA.FFTHit)
#my_proc.set_data_to_read(fmwk.DATA.MCTruth)
* Script : SysTable.py *
* Created : November 2012 *
* *
* Description: *
* Script for producing publication-quality systematics breakdown tables *
* *
* Authors: *
* HistFitter group *
* *
* Redistribution and use in source and binary forms, with or without *
* modification, are permitted according to the terms listed in the file *
* LICENSE. *
"""
from ROOT import gROOT, gSystem, gDirectory
gSystem.Load("libSusyFitter.so")
from ROOT import ConfigMgr, FitConfig #this module comes from gSystem.Load("libSusyFitter.so")
gROOT.Reset()
from ROOT import TFile, RooWorkspace, TObject, TString, RooAbsReal, RooRealVar, RooFitResult, RooDataSet, RooAddition, RooArgSet, RooAbsData, RooRandom, RooArgList
from ROOT import Util, TMath
from ROOT import RooFit
from ROOT import RooExpandedFitResult
from cmdLineUtils import getPdfInRegions, getName
import os
import sys
from sys import exit
from SysTableTex import *
'''
Look at STK cluster width and see if there is value to them
'''
from __future__ import division
import numpy as np
import math
import os
import pickle
from ROOT import gSystem
gSystem.Load("libDmpEvent.so")
import ROOT
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from getXTRL import calcRMS, CalcPosition, computeCOG, getEdep, cuts
def run(fname, pfile):
with open(fname, 'r') as f:
allF = []
for line in f:
allF.append(line.replace('\n', ''))
chain = ROOT.DmpChain("CollectionTree")
import sys
from ROOT import gSystem
from TextFile import ReadTextFile
from Directory import Directory
from ROOTFile import ROOTFile
P0DBANFF = os.getenv('P0DBANFFROOT')
RUNLISTS = P0DBANFF + '/run_lists'
RDP6M = 'rdp6_Spin_M'
MCP6B = 'mcp6_Spin_B/neut'
MCP6BANTI = 'mcp6_Spin_B/anti-neut'
MCP6LANTI = 'mcp6_Spin_L/anti-neut'
# this library helps ROOT not complain about missing dictionaries
gSystem.Load('%s/liboaAnalysisReader.so' % (
os.path.join(P0DBANFF, 'T2KReWeight/libReadoaAnalysis')))
def check_oaanalysis_files(file_list, file_list_name):
"""loop over run list file and check contents"""
if not isinstance(file_list, list):
file_list = ReadTextFile(file_list).get_file_as_list()
for analysis_file in file_list:
test_file = ROOTFile(analysis_file)
if not (test_file.contains(RDP6M) or test_file.contains(MCP6B) or
test_file.contains(MCP6BANTI) or test_file.contains(MCP6LANTI)):
print 'ROOT file \"%s\" does not contain right \
file path in %s' % (analysis_file, file_list_name)
elif test_file.checkfile() is not ROOTFile.IS_GOOD:
print 'ROOT file \"%s\" is BAD in %s' % \
(analysis_file, file_list_name)
def load_lib(libpath):
PInfo('PandaCore.Tools.Load', 'Loading %s' % libpath)
gSystem.Load(libpath)
'''Shows how to load a C++ class without dictionary in root 6.'''
from ROOT import gSystem, gROOT
import os
os.chdir('build/')
gROOT.ProcessLine('#include "hello.h"')
gSystem.Load('libhello')
from ROOT import Hello
hello = Hello()
hello.Print()
import sys
if len(sys.argv) < 2:
msg = '\n'
msg += "Usage 1: %s $INPUT_ROOT_FILE\n" % sys.argv[0]
msg += '\n'
sys.stderr.write(msg)
sys.exit(1)
from ROOT import gSystem
gSystem.Load("libSNCompression")
from ROOT import larlight as fmwk
# Create ana_processor instance
my_proc = fmwk.ana_processor()
# Set input root file
my_proc.add_input_file(sys.argv[1])
# Specify IO mode
my_proc.set_io_mode(fmwk.storage_manager.READ)
# Specify input TDirectory name if given
if len(sys.argv) > 2:
my_proc.set_input_rootdir(sys.argv[2])
# Specify output root file name
my_proc.set_ana_output_file("from_test_ana_you_can_remove_me.root")
# Attach a template process
import ROOT, math, sys
import numpy as np
import pandas, root_numpy
from copy import deepcopy as dc
from ROOT import gSystem
gSystem.Load('libRooFit')
from ROOT import RooFit, RooRealVar, RooDataSet, RooArgList, RooTreeData, RooArgSet, RooAddPdf, RooFormulaVar, RooExtendPdf
from ROOT import RooGaussian, RooExponential, RooChebychev
ROOT.gROOT.SetBatch(True)
# ROOT.gErrorIgnoreLevel = ROOT.kFatal
# ROOT.RooMsgService.instance().setSilentMode(True)
B0Mass_ = 5.27958
JPsiMass_ = 3.096916
PsiPMass_ = 3.686109
KStMass_ = 0.896
B0Mass = RooRealVar("B0Mass", "B0Mass", B0Mass_)
JPsiMass = RooRealVar("JPsiMass", "JPsiMass", JPsiMass_)
PsiPMass = RooRealVar("PsiPMass", "PsiPMass", PsiPMass_)
KStMass = RooRealVar("KStMass", "KStMass", KStMass_)
nSigma_psiRej = 3.
outfile = ROOT.TFile('outcome_wp_finding_massFlatten_onlyRT_NoB0PsiCut.root',
'recreate')
n_bdt_points = 15
sample_range = 11
from Centella.AAlgo import AAlgo
from Centella.physical_constants import *
from Centella.system_of_units import *
from Util import *
from Nh5 import *
import numpy as np
import tables
from time import time
from ROOT import gSystem
gSystem.Load("$GATE_DIR/lib/libGATE")
from ROOT import gate
from math import sqrt
class MCWF(AAlgo):
def __init__(self, param=False, level=1, label="", **kargs):
"""
"""
self.name = 'MCWaveform'
AAlgo.__init__(self, param, level, self.name, 0, label, kargs)
def initialize(self):
"""
tables.EArray(parentnode, name, atom=None, shape=None,
title='', filters=None, expectedrows=None,
## LOGGER
import logging
import logging.config
logger = logging.getLogger(__name__)
logging.basicConfig(format="%(asctime)-15s %(levelname)s - %(message)s",datefmt='%Y-%m-%d %H:%M:%S')
logger= logging.getLogger(__name__)
logger.setLevel(logging.INFO)
## ROOT + CAESAR
try:
## ROOT
import ROOT
from ROOT import gSystem, gROOT, AddressOf
## CAESAR
gSystem.Load('libCaesar.so')
from ROOT import Caesar
from ROOT.Caesar import Image
except:
logger.error("Cannot load ROOT & Caesar modules!")
exit(1)
def make_caesar_source(source_data,source_name,source_id,source_type,offsetx=0,offsety=0,beamArea=0):
""" Create Caesar source from source data array """
# - Create Caesar source
source= Caesar.Source()
# - Get source indexes and fill pixels in Caesar source
import os
import ROOT
from CMGTools.RootTools.RootTools import *
from ROOT import gSystem
gSystem.Load('CMGToolsHToZZTo4Leptons')
from ROOT import KD
# you can even create a python class for high level stuff, like this:
class KDCalculator(object):
'''This class Calculates the KDs .'''
def __init__(self):
self.KD = KD()
def calculate(self, FL):
if FL.M() < 0:
FL.KD = -99.
FL.pseudoKD = -99.
FL.graviKD = -99.
return
l1 = ROOT.TLorentzVector(FL.leg1.leg1.px(), FL.leg1.leg1.py(),
FL.leg1.leg1.pz(), FL.leg1.leg1.energy())
l2 = ROOT.TLorentzVector(FL.leg1.leg2.px(), FL.leg1.leg2.py(),
FL.leg1.leg2.pz(), FL.leg1.leg2.energy())
l3 = ROOT.TLorentzVector(FL.leg2.leg1.px(), FL.leg2.leg1.py(),
FL.leg2.leg1.pz(), FL.leg2.leg1.energy())
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
import os
import sys, string, commands
from datetime import datetime
## Needed to correct ROOT behavior; see below
CWD = os.getcwd()
import ROOT
## Importing gSystem may change the current directory to one of the
## command-line arguments; chdir to original directory to have
## predictable behavior
from ROOT import gSystem
os.chdir(CWD)
## Import the ROOT library for reading han results
gSystem.Load('libGoodRunsListsLib')
from ROOT import Root
## read the goodrunslist xml file(s)
reader = Root.TGoodRunsListReader()
reader.SetXMLFile('Cosmics_DQgood_runlist.xml')
reader.Interpret()
grl = reader.GetMergedGoodRunsList()
## show summary of content
grl.Summary() ## Detailed: Summary(True)
### read grl cosmics all
#reader.SetXMLFile('Cosmics_ProcessedLBsNoDQSelection.xml')
#reader.Interpret()
#grl_all = reader.GetMergedGoodRunsList()
# For the licensing terms see $DD4hepINSTALL/LICENSE.
# For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
#
# ==========================================================================
#
from __future__ import absolute_import, unicode_literals
import traceback
import sys
from ROOT import gSystem
import os
import logging
import platform
if platform.system() == "Darwin":
gSystem.SetDynamicPath(os.environ['DD4HEP_LIBRARY_PATH'])
gSystem.Load('libglapi')
gSystem.Load('libDDPython')
from ROOT import dd4hep as Core # noqa
logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.INFO)
logger = logging.getLogger(__name__)
name_space = __import__(__name__)
def import_namespace_item(ns, nam):
scope = getattr(name_space, ns)
attr = getattr(scope, nam)
setattr(name_space, nam, attr)
return attr
import sys
from ROOT import gSystem
gSystem.Load("libCommissioning_MakeWFTTree")
from ROOT import sample
try:
print "PyROOT recognized your class %s" % str(sample)
except NameError:
print "Failed importing MakeWFTTree..."
sys.exit(0)
import sys
if len(sys.argv) < 2:
msg = '\n'
msg += "Usage 1: %s $INPUT_ROOT_FILE\n" % sys.argv[0]
msg += '\n'
sys.stderr.write(msg)
sys.exit(1)
from ROOT import gSystem
gSystem.Load("libKalekoAna")
from ROOT import larlight as fmwk
from ROOT import kaleko
# Create ana_processor instance
my_proc = fmwk.ana_processor()
my_proc.set_verbosity(fmwk.MSG.NORMAL)
# Set input root file
my_proc.add_input_file(sys.argv[1])
# Have it find the scanner directory
#fmwk.storage_manager.get().set_in_rootdir("scanner")
fmwk.storage_manager.get().set_data_to_read(fmwk.DATA.MCTruth,False)
fmwk.storage_manager.get().set_data_to_read(fmwk.DATA.Calorimetry,False)
fmwk.storage_manager.get().set_data_to_read(fmwk.DATA.Shower,False)
#fmwk.storage_manager.get().set_data_to_read(fmwk.DATA.ShowerAngleCluster,False)
# Specify IO mode
my_proc.set_io_mode(fmwk.storage_manager.READ)
#if (ievt % 1000) == 0:
# print "Processing event: %i" % ievt
self.process(evt)
yield evt
return
def process(self, event):
self.getHandles(event)
return
def getHandles(self, event):
for k, v in self.handles.iteritems():
label = self.handle_labels[k]
event.getByLabel(label, v)
return
# ______________________________________________________________________________
if __name__ == "__main__":
print "Loading FW Lite"
gSystem.Load("libFWCoreFWLite")
gROOT.ProcessLine("FWLiteEnabler::enable();")
#gSystem.Load("libDataFormatsFWLite.so")
#gSystem.Load("libDataFormatsPatCandidates.so")
#gSystem.Load("libDataFormatsL1TMuon.so")
analyzer = FWLiteAnalyzer(inputFiles='pippo.root')
analyzer.analyze()
import sys
if len(sys.argv) < 2:
msg = '\n'
msg += "Usage 1: %s $INPUT_ROOT_FILE\n" % sys.argv[0]
msg += '\n'
sys.stderr.write(msg)
sys.exit(1)
from ROOT import gSystem
gSystem.Load("libArianaPi0Test")
from ROOT import larlight as fmwk
# Create ana_processor instance
my_proc = fmwk.ana_processor()
#my_proc.add_input_file(sys.argv[1])
# Set input root file
for x in xrange(len(sys.argv)-1):
my_proc.add_input_file(sys.argv[x+1])
#my_proc.add_input_file("~/WorkArea/data/NewFiles/LArLight/pdg_111/combined_cluster_00.root")
# Specify IO mode
my_proc.set_io_mode(fmwk.storage_manager.READ)
my_proc.set_rootdir("scanner")
# Specify output root file name
my_proc.set_ana_output_file("ana.root");
#!/usr/bin/python
import os
import sys, string, commands
from datetime import datetime
## Needed to correct ROOT behavior; see below
CWD = os.getcwd()
import ROOT
## Importing gSystem may change the current directory to one of the
## command-line arguments; chdir to original directory to have
## predictable behavior
from ROOT import gSystem
os.chdir(CWD)
## Import the ROOT library for reading han results
gSystem.Load('../StandAlone/libGoodRunsLists.so')
from ROOT import Root
## read the goodrunslist xml file(s)
reader = Root.TGoodRunsListReader('LumiRangeCollectionA.xml')
#reader.AddXMLFile('LumiRangeCollectionB.xml')
reader.Interpret()
goodrunslist = reader.GetMergedGRLCollection()
## show summary of content
goodrunslist.Summary() ## Detailed: Summary(True)
## constains run and/or lumiblock ?
if goodrunslist.HasRun(90210): print "Foo!" # contains run 90210 ?
if goodrunslist.HasRunLumiBlock(90210, 7): print "Bar!" # run 90210, lb 7 ?
from ROOT import gSystem
gSystem.Load("libanalysiscpp-myanalysis")
from ROOT import MyAnalysis, TCanvas, gPad
ma = MyAnalysis()
ma.loop("example.root")
c1 = TCanvas()
c1.Divide(2,1)
c1.cd(1)
ma.m_hjetenergy.Draw()
c1.cd(2)
ma.m_hjetnparts.Draw()
gPad.Update()
