/[escript]/trunk/escriptcore/test/python/test_util_spatial_functions2.py
ViewVC logotype

Diff of /trunk/escriptcore/test/python/test_util_spatial_functions2.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 3797 by gross, Thu Feb 2 09:28:59 2012 UTC revision 3798 by gross, Thu Feb 2 09:47:27 2012 UTC
# Line 84959  class Test_Util_SpatialFunctions_noGradO Line 84959  class Test_Util_SpatialFunctions_noGradO
84959        self.assertEqual(res.shape,(3, 2, 3, 4),"wrong shape of result.")        self.assertEqual(res.shape,(3, 2, 3, 4),"wrong shape of result.")
84960        self.assertTrue(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")        self.assertTrue(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
84961    
84962       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onSolution_rank0(self):
84963          """
84964          test interploation of constant rank 0 Data on ReducedFunctionOnContactZero
84965          """
84966          w_ref = ReducedFunctionOnContactZero(self.domain)
84967          w_arg = Solution(self.domain)
84968          val = 6.330481e-01
84969          arg = Data(val,(),w_arg)
84970          res=interpolate(arg,where=w_ref)
84971          self.assertTrue(isinstance(res,Data),"wrong type of result.")
84972          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
84973          self.assertEqual(res.getShape(),(),"wrong shape of result.")
84974          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
84975       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onSolution_rank1(self):
84976          """
84977          test interploation of constant rank 1 Data on ReducedFunctionOnContactZero
84978          """
84979          w_ref = ReducedFunctionOnContactZero(self.domain)
84980          w_arg = Solution(self.domain)
84981          val = numpy.array([0.3847303032020608, 0.18147843998408453, 0.9940159412204554] ,numpy.float_)
84982          arg = Data(val,w_arg)
84983          res=interpolate(arg,where=w_ref)
84984          self.assertTrue(isinstance(res,Data),"wrong type of result.")
84985          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
84986          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
84987          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
84988       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onSolution_rank2(self):
84989          """
84990          test interploation of constant rank 2 Data on ReducedFunctionOnContactZero
84991          """
84992          w_ref = ReducedFunctionOnContactZero(self.domain)
84993          w_arg = Solution(self.domain)
84994          val = numpy.array([[0.8208577150352943, 0.09873815987394452], [0.5093250544122111, 0.23094291531128197], [0.8514022708471113, 0.964575355993364], [0.1701391961561992, 0.5068419792686839]] ,numpy.float_)
84995          arg = Data(val,w_arg)
84996          res=interpolate(arg,where=w_ref)
84997          self.assertTrue(isinstance(res,Data),"wrong type of result.")
84998          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
84999          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
85000          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85001       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onSolution_rank3(self):
85002          """
85003          test interploation of constant rank 3 Data on ReducedFunctionOnContactZero
85004          """
85005          w_ref = ReducedFunctionOnContactZero(self.domain)
85006          w_arg = Solution(self.domain)
85007          val = numpy.array([[[0.7491660335810698, 0.3781943908730171, 0.4830612377154747, 0.2071669494998487], [0.22960699147160069, 0.13733653174183047, 0.6244232542514038, 0.14146042232141587]], [[0.37818031217364223, 0.8943647335540977, 0.09036738509105202, 0.09622127906237554], [0.07210102540329866, 0.6388556126198095, 0.6769400669818662, 0.9143536767117854]]] ,numpy.float_)
85008          arg = Data(val,w_arg)
85009          res=interpolate(arg,where=w_ref)
85010          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85011          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85012          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
85013          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85014       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onSolution_rank4(self):
85015          """
85016          test interploation of constant rank 4 Data on ReducedFunctionOnContactZero
85017          """
85018          w_ref = ReducedFunctionOnContactZero(self.domain)
85019          w_arg = Solution(self.domain)
85020          val = numpy.array([[[[0.6718250462032066, 0.29986789507335887, 0.3110256285500069, 0.6505477317104773], [0.3425951754134493, 0.237344842051738, 0.8275585108656683, 0.24519009486586185], [0.4031511524830552, 0.3166140413376468, 0.10005471556181855, 0.3254197030312074]], [[0.40617481107025755, 0.44726801873832145, 0.09071143280787397, 0.883474185942764], [0.5237359517089172, 0.08126785760724764, 0.3009184406804586, 0.7160481900774361], [0.7655847125163144, 0.4249660271184704, 0.5008962498494155, 0.7249237060161606]]], [[[0.7360051119017891, 0.645888226793658, 0.26714392703105694, 0.6022966727656676], [0.287507561238987, 0.9930331748985254, 0.7232020632371701, 0.20292202319445463], [0.889796327571103, 0.9949184984621474, 0.24426073838085904, 0.09731117222288488]], [[0.35228314971731745, 0.9002459954269506, 0.3781967829699544, 0.7230201407340527], [0.5077124957966629, 0.43840369649254507, 0.6237226329227449, 0.8546983335504517], [0.42257658812665655, 0.5580163776126614, 0.9837258019585285, 0.8217156175026029]]], [[[0.06540846082131235, 0.976259392997154, 0.8071483996891965, 0.8526377776948062], [0.8573384175848723, 0.5268058810408864, 0.4368408388051713, 0.38593395831850486], [0.13005523827196253, 0.57482486773416, 0.22344636722953815, 0.62639297295493]], [[0.42475203937081163, 0.1052269050588911, 0.36255917905669044, 0.9859470428887305], [0.29801058959055027, 0.6325110092015462, 0.9093463197409053, 0.44900542105854613], [0.8555544210803229, 0.46929767874235195, 0.943608161714152, 0.4012514339786649]]]] ,numpy.float_)
85021          arg = Data(val,w_arg)
85022          res=interpolate(arg,where=w_ref)
85023          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85024          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85025          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
85026          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85027       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onReducedSolution_rank0(self):
85028          """
85029          test interploation of constant rank 0 Data on ReducedFunctionOnContactZero
85030          """
85031          w_ref = ReducedFunctionOnContactZero(self.domain)
85032          w_arg = ReducedSolution(self.domain)
85033          val = 6.060676e-01
85034          arg = Data(val,(),w_arg)
85035          res=interpolate(arg,where=w_ref)
85036          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85037          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85038          self.assertEqual(res.getShape(),(),"wrong shape of result.")
85039          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85040       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onReducedSolution_rank1(self):
85041          """
85042          test interploation of constant rank 1 Data on ReducedFunctionOnContactZero
85043          """
85044          w_ref = ReducedFunctionOnContactZero(self.domain)
85045          w_arg = ReducedSolution(self.domain)
85046          val = numpy.array([0.6906812771893213, 0.8080673054304435, 0.18950422823206092] ,numpy.float_)
85047          arg = Data(val,w_arg)
85048          res=interpolate(arg,where=w_ref)
85049          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85050          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85051          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
85052          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85053       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onReducedSolution_rank2(self):
85054          """
85055          test interploation of constant rank 2 Data on ReducedFunctionOnContactZero
85056          """
85057          w_ref = ReducedFunctionOnContactZero(self.domain)
85058          w_arg = ReducedSolution(self.domain)
85059          val = numpy.array([[0.9189228069867992, 0.6324602542639153], [0.2443545392607157, 0.3343650598287712], [0.8924484055230667, 0.17086476689686925], [0.35033597738746536, 0.8369454502618392]] ,numpy.float_)
85060          arg = Data(val,w_arg)
85061          res=interpolate(arg,where=w_ref)
85062          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85063          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85064          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
85065          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85066       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onReducedSolution_rank3(self):
85067          """
85068          test interploation of constant rank 3 Data on ReducedFunctionOnContactZero
85069          """
85070          w_ref = ReducedFunctionOnContactZero(self.domain)
85071          w_arg = ReducedSolution(self.domain)
85072          val = numpy.array([[[0.1371143725861017, 0.27932715073173353, 0.8332259067661251, 0.5600063787568943], [0.15385825515609697, 0.1360435698355964, 0.03782448970361396, 0.8991865253916586]], [[0.9956674984525522, 0.10160961705635152, 0.10486501883304411, 0.49770198355059925], [0.9065287567680511, 0.02267047480629869, 0.6611001335973236, 0.5826742825885743]]] ,numpy.float_)
85073          arg = Data(val,w_arg)
85074          res=interpolate(arg,where=w_ref)
85075          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85076          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85077          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
85078          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85079       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onReducedSolution_rank4(self):
85080          """
85081          test interploation of constant rank 4 Data on ReducedFunctionOnContactZero
85082          """
85083          w_ref = ReducedFunctionOnContactZero(self.domain)
85084          w_arg = ReducedSolution(self.domain)
85085          val = numpy.array([[[[0.022691076620816264, 0.3533832857970205, 0.22963568350150954, 0.3119816493309603], [0.30749262016843926, 0.3802296216499901, 0.888625527211768, 0.4500410463056953], [0.1917849079730395, 0.8655154716792614, 0.3126308600286407, 0.5634837550587327]], [[0.2671124850384601, 0.26264477741416936, 0.2551979655454538, 0.6341046713691291], [0.8427325869234399, 0.5541237773217742, 0.6464530250228733, 0.34166173622784846], [0.4462343254076133, 0.07170831770550479, 0.6450594807332083, 0.5638453648893454]]], [[[0.6428418052354318, 0.7845310997782408, 0.22425876876725304, 0.6594252698861488], [0.0031929191359137965, 0.7385874585595147, 0.8927545724866874, 0.5366771586030736], [0.4144854731621478, 0.7120521093816342, 0.22654211118026113, 0.21291824748884214]], [[0.12295192321295256, 0.47592588369927835, 0.08777102342109055, 0.6272600801153061], [0.6632518810004022, 0.1554615488029818, 0.6344576003922896, 0.4871102916959503], [0.9563569625929726, 0.7356299835937146, 0.28505760780484, 0.7015914590499053]]], [[[0.2739320241578147, 0.17202057977629126, 0.6505355163093913, 0.08869773363864453], [0.09384858129857321, 0.7079227547938437, 0.12608403625539966, 0.19892160601287967], [0.020640043648576967, 0.6406729684511675, 0.060555290561925434, 0.2410308886677397]], [[0.45734559875986935, 0.15119106903657464, 0.8378657034068868, 0.7826598202086885], [0.23873198700457376, 0.11302876445582, 0.6799950963335898, 0.888270753284121], [0.9401794196258947, 0.12966317539066152, 0.2054096343050703, 0.033157530789681866]]]] ,numpy.float_)
85086          arg = Data(val,w_arg)
85087          res=interpolate(arg,where=w_ref)
85088          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85089          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85090          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
85091          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85092       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onContinuousFunction_rank0(self):
85093          """
85094          test interploation of constant rank 0 Data on ReducedFunctionOnContactZero
85095          """
85096          w_ref = ReducedFunctionOnContactZero(self.domain)
85097          w_arg = ContinuousFunction(self.domain)
85098          val = 2.953078e-01
85099          arg = Data(val,(),w_arg)
85100          res=interpolate(arg,where=w_ref)
85101          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85102          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85103          self.assertEqual(res.getShape(),(),"wrong shape of result.")
85104          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85105       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onContinuousFunction_rank1(self):
85106          """
85107          test interploation of constant rank 1 Data on ReducedFunctionOnContactZero
85108          """
85109          w_ref = ReducedFunctionOnContactZero(self.domain)
85110          w_arg = ContinuousFunction(self.domain)
85111          val = numpy.array([0.3845355597359712, 0.86963576072494, 0.860449577218653] ,numpy.float_)
85112          arg = Data(val,w_arg)
85113          res=interpolate(arg,where=w_ref)
85114          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85115          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85116          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
85117          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85118       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onContinuousFunction_rank2(self):
85119          """
85120          test interploation of constant rank 2 Data on ReducedFunctionOnContactZero
85121          """
85122          w_ref = ReducedFunctionOnContactZero(self.domain)
85123          w_arg = ContinuousFunction(self.domain)
85124          val = numpy.array([[0.2391570735164953, 0.13196946368084606], [0.8905912217245331, 0.2633768917539586], [0.9942298991861107, 0.04095865299879475], [0.5319312721065134, 0.30463112816560534]] ,numpy.float_)
85125          arg = Data(val,w_arg)
85126          res=interpolate(arg,where=w_ref)
85127          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85128          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85129          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
85130          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85131       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onContinuousFunction_rank3(self):
85132          """
85133          test interploation of constant rank 3 Data on ReducedFunctionOnContactZero
85134          """
85135          w_ref = ReducedFunctionOnContactZero(self.domain)
85136          w_arg = ContinuousFunction(self.domain)
85137          val = numpy.array([[[0.49114265807832236, 0.5114581577573066, 0.07169960652055996, 0.5790704426790384], [0.24459129723452055, 0.9270936133699866, 0.23726899132346013, 0.0002064213290204897]], [[0.6672202726944024, 0.24120842266787224, 0.17381308263223705, 0.1101699489616379], [0.8828201656638118, 0.1382703833214055, 0.17282279637210474, 0.7178295790711469]]] ,numpy.float_)
85138          arg = Data(val,w_arg)
85139          res=interpolate(arg,where=w_ref)
85140          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85141          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85142          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
85143          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85144       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onContinuousFunction_rank4(self):
85145          """
85146          test interploation of constant rank 4 Data on ReducedFunctionOnContactZero
85147          """
85148          w_ref = ReducedFunctionOnContactZero(self.domain)
85149          w_arg = ContinuousFunction(self.domain)
85150          val = numpy.array([[[[0.4177653109650642, 0.022048657361918855, 0.32211678042604097, 0.9167709922903761], [0.6305143539043071, 0.02688412728450229, 0.06774737721874857, 0.3869922454029354], [0.5207547772063892, 0.9024539465085347, 0.19500996893906075, 0.0699550058918712]], [[0.5214720360088625, 0.8923763386480904, 0.873629151274173, 0.15404777664370894], [0.22574408035014037, 0.47684933810233454, 0.024085677923542437, 0.8462778314593252], [0.7068568127163424, 0.6099199461074133, 0.3367659761357047, 0.06252752040143872]]], [[[0.7192944587704798, 0.7154141744368239, 0.866664975241598, 0.08144122888135519], [0.5406658086312278, 0.390914122127785, 0.11957371108187709, 0.47500971947916004], [0.20659400046479626, 0.9089315863431751, 0.045064233162471545, 0.5061581898715457]], [[0.13414661038966558, 0.7044852073513079, 0.5472034417406056, 0.24382822233230228], [0.8671501210548861, 0.594835404447363, 0.07193521431193228, 0.45258925073459666], [0.816348999762677, 0.5448395518611996, 0.9073949904252755, 0.582188410102424]]], [[[0.9380939915342696, 0.4430838483114308, 0.520938271411763, 0.2902246651283391], [0.321815594116018, 0.9448965469327676, 0.3669063245652392, 0.3891845259433939], [0.37459193705443306, 0.43904226883456976, 0.9886164692558943, 0.8348602912755285]], [[0.599507447191334, 0.31989050757525916, 0.566426966823346, 0.851646110756947], [0.2308476866140663, 0.6053061279907493, 0.6691753057313028, 0.07258897990499413], [0.8255340902720096, 0.9386906408948554, 0.8584606721948733, 0.5226931993562006]]]] ,numpy.float_)
85151          arg = Data(val,w_arg)
85152          res=interpolate(arg,where=w_ref)
85153          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85154          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85155          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
85156          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85157       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onReducedContinuousFunction_rank0(self):
85158          """
85159          test interploation of constant rank 0 Data on ReducedFunctionOnContactZero
85160          """
85161          w_ref = ReducedFunctionOnContactZero(self.domain)
85162          w_arg = ReducedContinuousFunction(self.domain)
85163          val = 9.336493e-01
85164          arg = Data(val,(),w_arg)
85165          res=interpolate(arg,where=w_ref)
85166          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85167          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85168          self.assertEqual(res.getShape(),(),"wrong shape of result.")
85169          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85170       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onReducedContinuousFunction_rank1(self):
85171          """
85172          test interploation of constant rank 1 Data on ReducedFunctionOnContactZero
85173          """
85174          w_ref = ReducedFunctionOnContactZero(self.domain)
85175          w_arg = ReducedContinuousFunction(self.domain)
85176          val = numpy.array([0.9886775563609929, 0.7371308938062822, 0.21931795217365824] ,numpy.float_)
85177          arg = Data(val,w_arg)
85178          res=interpolate(arg,where=w_ref)
85179          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85180          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85181          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
85182          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85183       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onReducedContinuousFunction_rank2(self):
85184          """
85185          test interploation of constant rank 2 Data on ReducedFunctionOnContactZero
85186          """
85187          w_ref = ReducedFunctionOnContactZero(self.domain)
85188          w_arg = ReducedContinuousFunction(self.domain)
85189          val = numpy.array([[0.03840819862857736, 0.2863633250961184], [0.10559124679039344, 0.6597256040849194], [0.6834773541555171, 0.08984943899067521], [0.5554228448357418, 0.24623960618512575]] ,numpy.float_)
85190          arg = Data(val,w_arg)
85191          res=interpolate(arg,where=w_ref)
85192          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85193          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85194          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
85195          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85196       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onReducedContinuousFunction_rank3(self):
85197          """
85198          test interploation of constant rank 3 Data on ReducedFunctionOnContactZero
85199          """
85200          w_ref = ReducedFunctionOnContactZero(self.domain)
85201          w_arg = ReducedContinuousFunction(self.domain)
85202          val = numpy.array([[[0.6998941906226313, 0.5445760547127386, 0.8240769290809731, 0.4930422827933304], [0.5495397542781163, 0.5481843020010052, 0.318488359313044, 0.27990975787465844]], [[0.7934430793601053, 0.5865665319041602, 0.48807037742756476, 0.12129081360504934], [0.5387314642640326, 0.6309147992160005, 0.24912452158413756, 0.03709618533286696]]] ,numpy.float_)
85203          arg = Data(val,w_arg)
85204          res=interpolate(arg,where=w_ref)
85205          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85206          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85207          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
85208          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85209       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onReducedContinuousFunction_rank4(self):
85210          """
85211          test interploation of constant rank 4 Data on ReducedFunctionOnContactZero
85212          """
85213          w_ref = ReducedFunctionOnContactZero(self.domain)
85214          w_arg = ReducedContinuousFunction(self.domain)
85215          val = numpy.array([[[[0.9715664343159572, 0.32752605420346126, 0.2824848280267871, 0.4818122416757301], [0.6879926771276003, 0.8237721056402665, 0.7808412589457396, 0.837291221343629], [0.5376960220803515, 0.8923558915759796, 0.1548666220868764, 0.3001463620657945]], [[0.23778938614690148, 0.3385349525635021, 0.5784384199497421, 0.7622321212352097], [0.17022291578508597, 0.9741360537357493, 0.9096895999046625, 0.7403275182578618], [0.7278428470859918, 0.4778837898750473, 0.6244526122200538, 0.0347146372826983]]], [[[0.8064459100141096, 0.24752283512140105, 0.9194679072205766, 0.7831085881551937], [0.7712832368840539, 0.04759291077119143, 0.1873206066440508, 0.20730513192178146], [0.9557277074068693, 0.49247458874729144, 0.6541002686400001, 0.5666224264597615]], [[0.26193614602389503, 0.4931898599678237, 0.37706513558147137, 0.22420559658361006], [0.8441673464097529, 0.23839173726723328, 0.8498057027761104, 0.912847323167645], [0.20340678621086516, 0.5760352923021739, 0.8840542659302092, 0.3972551752198177]]], [[[0.9150643763361181, 0.8072203610679646, 0.7331420529781646, 0.8875565620599876], [0.04532661462352716, 0.03084912626985492, 0.6677352277139321, 0.7952195557705751], [0.865479095047719, 0.5498754718191168, 0.7595284821539301, 0.8943334530638315]], [[0.854073454824556, 0.8243569907298768, 0.6091993157376407, 0.5725659926415532], [0.9001563151081481, 0.11206572300738216, 0.7588389019081724, 0.32565137107019126], [0.6586759823342888, 0.7926285686252127, 0.7849075359860759, 0.07231631299643582]]]] ,numpy.float_)
85216          arg = Data(val,w_arg)
85217          res=interpolate(arg,where=w_ref)
85218          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85219          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85220          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
85221          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85222       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onReducedFunctionOnContactZero_rank0(self):
85223          """
85224          test interploation of constant rank 0 Data on ReducedFunctionOnContactZero
85225          """
85226          w_ref = ReducedFunctionOnContactZero(self.domain)
85227          w_arg = ReducedFunctionOnContactZero(self.domain)
85228          val = 1.145868e-01
85229          arg = Data(val,(),w_arg)
85230          res=interpolate(arg,where=w_ref)
85231          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85232          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85233          self.assertEqual(res.getShape(),(),"wrong shape of result.")
85234          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85235       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onReducedFunctionOnContactZero_rank1(self):
85236          """
85237          test interploation of constant rank 1 Data on ReducedFunctionOnContactZero
85238          """
85239          w_ref = ReducedFunctionOnContactZero(self.domain)
85240          w_arg = ReducedFunctionOnContactZero(self.domain)
85241          val = numpy.array([0.014598946816728353, 0.5388924052004451, 0.11653148663685087] ,numpy.float_)
85242          arg = Data(val,w_arg)
85243          res=interpolate(arg,where=w_ref)
85244          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85245          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85246          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
85247          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85248       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onReducedFunctionOnContactZero_rank2(self):
85249          """
85250          test interploation of constant rank 2 Data on ReducedFunctionOnContactZero
85251          """
85252          w_ref = ReducedFunctionOnContactZero(self.domain)
85253          w_arg = ReducedFunctionOnContactZero(self.domain)
85254          val = numpy.array([[0.4687889567219372, 0.8332212565567162], [0.3182681090046857, 0.9832559077365997], [0.11014662238585038, 0.13385077568540205], [0.08981551850674097, 0.5316857454980802]] ,numpy.float_)
85255          arg = Data(val,w_arg)
85256          res=interpolate(arg,where=w_ref)
85257          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85258          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85259          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
85260          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85261       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onReducedFunctionOnContactZero_rank3(self):
85262          """
85263          test interploation of constant rank 3 Data on ReducedFunctionOnContactZero
85264          """
85265          w_ref = ReducedFunctionOnContactZero(self.domain)
85266          w_arg = ReducedFunctionOnContactZero(self.domain)
85267          val = numpy.array([[[0.05136782848478505, 0.3616174604014717, 0.6697031846273365, 0.860200631168688], [0.1921153223733585, 0.35808933704543067, 0.8931558333595058, 0.2477142901806817]], [[0.4019306698584463, 0.10089461702836311, 0.2579939066532463, 0.3591614996527942], [0.6164648682436485, 0.05735063809883212, 0.9986841542843176, 0.6569099434982767]]] ,numpy.float_)
85268          arg = Data(val,w_arg)
85269          res=interpolate(arg,where=w_ref)
85270          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85271          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85272          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
85273          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85274       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onReducedFunctionOnContactZero_rank4(self):
85275          """
85276          test interploation of constant rank 4 Data on ReducedFunctionOnContactZero
85277          """
85278          w_ref = ReducedFunctionOnContactZero(self.domain)
85279          w_arg = ReducedFunctionOnContactZero(self.domain)
85280          val = numpy.array([[[[0.5669971366164621, 0.01580416307767185, 0.06630517589952745, 0.20221007560758097], [0.6462771999580642, 0.49763664243966543, 0.3130784507172122, 0.6131089351944367], [0.36957178626595055, 0.196712238820288, 0.7046759237509974, 0.4674503083951723]], [[0.19678777278077786, 0.46279123374341846, 0.08371063082219199, 0.8630282074251086], [0.010862230782281768, 0.5353974080065692, 0.668479523216562, 0.5872003221351528], [0.24333529376096674, 0.6820999275882298, 0.7379304485334041, 0.8634803176515862]]], [[[0.30704201191215263, 0.4846064810266443, 0.8579185986412746, 0.6619678720765588], [0.13049096224896362, 0.36738583684508674, 0.777977515981437, 0.5474162683860738], [0.7323121470823193, 0.35510805665931977, 0.551877783225242, 0.4074331295993565]], [[0.9057579970974661, 0.12898104422287127, 0.3694441975069761, 0.17720135222892186], [0.24507243089248587, 0.5564811310765988, 0.7601307740503912, 0.6152450121219499], [0.0014042221665896415, 0.9888021516097056, 0.7681816977068601, 0.9482445981610248]]], [[[0.30785109330412164, 0.10846490575464107, 0.24131043343856173, 0.1060095502125532], [0.7187153578512048, 0.19493814498017836, 0.755229006295177, 0.7805905502479094], [0.6863504395822222, 0.4127326393501052, 0.6796023652441215, 0.3444834871632124]], [[0.33534234836702137, 0.14493680932633346, 0.9129475017077021, 0.5247811551194456], [0.9324156260291195, 0.7598352779583928, 0.18700945199655483, 0.5917312925076152], [0.8358592737177373, 0.24182847710499955, 0.9192976791320597, 0.7813867633950601]]]] ,numpy.float_)
85281          arg = Data(val,w_arg)
85282          res=interpolate(arg,where=w_ref)
85283          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85284          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85285          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
85286          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85287       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onReducedFunctionOnContactOne_rank0(self):
85288          """
85289          test interploation of constant rank 0 Data on ReducedFunctionOnContactZero
85290          """
85291          w_ref = ReducedFunctionOnContactZero(self.domain)
85292          w_arg = ReducedFunctionOnContactOne(self.domain)
85293          val = 6.943884e-01
85294          arg = Data(val,(),w_arg)
85295          res=interpolate(arg,where=w_ref)
85296          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85297          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85298          self.assertEqual(res.getShape(),(),"wrong shape of result.")
85299          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85300       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onReducedFunctionOnContactOne_rank1(self):
85301          """
85302          test interploation of constant rank 1 Data on ReducedFunctionOnContactZero
85303          """
85304          w_ref = ReducedFunctionOnContactZero(self.domain)
85305          w_arg = ReducedFunctionOnContactOne(self.domain)
85306          val = numpy.array([0.8372061535054994, 0.40521616915850245, 0.2114836970531737] ,numpy.float_)
85307          arg = Data(val,w_arg)
85308          res=interpolate(arg,where=w_ref)
85309          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85310          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85311          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
85312          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85313       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onReducedFunctionOnContactOne_rank2(self):
85314          """
85315          test interploation of constant rank 2 Data on ReducedFunctionOnContactZero
85316          """
85317          w_ref = ReducedFunctionOnContactZero(self.domain)
85318          w_arg = ReducedFunctionOnContactOne(self.domain)
85319          val = numpy.array([[0.7256493770622505, 0.1482312462529609], [0.7360015002282804, 0.8691433215929194], [0.4689098845451053, 0.7848275761816804], [0.8181516879866743, 0.14911338186871803]] ,numpy.float_)
85320          arg = Data(val,w_arg)
85321          res=interpolate(arg,where=w_ref)
85322          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85323          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85324          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
85325          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85326       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onReducedFunctionOnContactOne_rank3(self):
85327          """
85328          test interploation of constant rank 3 Data on ReducedFunctionOnContactZero
85329          """
85330          w_ref = ReducedFunctionOnContactZero(self.domain)
85331          w_arg = ReducedFunctionOnContactOne(self.domain)
85332          val = numpy.array([[[0.7741108313841725, 0.07867597832568796, 0.8507932534778745, 0.6665074031633893], [0.877758564384925, 0.674167604795121, 0.2302869285324297, 0.8469510858777648]], [[0.37767868542544036, 0.3228960140301764, 0.8278726185576784, 0.013272790670921353], [0.5325634136266355, 0.9851843369303385, 0.24910698717180257, 0.004955611133203752]]] ,numpy.float_)
85333          arg = Data(val,w_arg)
85334          res=interpolate(arg,where=w_ref)
85335          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85336          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85337          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
85338          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85339       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onReducedFunctionOnContactOne_rank4(self):
85340          """
85341          test interploation of constant rank 4 Data on ReducedFunctionOnContactZero
85342          """
85343          w_ref = ReducedFunctionOnContactZero(self.domain)
85344          w_arg = ReducedFunctionOnContactOne(self.domain)
85345          val = numpy.array([[[[0.8611161439388498, 0.32155962199210253, 0.8254098053890913, 0.12982886989501508], [0.5249916045648777, 0.35397017216685167, 0.83020214979672, 0.1589582377841191], [0.6040215924739342, 0.13679638110767178, 0.06346565279053529, 0.324727569733824]], [[0.12496625827234364, 0.39366045280136186, 0.906850882184089, 0.7599170488161139], [0.19052455076162222, 0.017538106911885176, 0.40142412278443895, 0.9441545680896254], [0.763718658605361, 0.9796213536747616, 0.9228333540472967, 0.5125569156059232]]], [[[0.026040922654592014, 0.6229045466950793, 0.7167729239585867, 0.3048067903231889], [0.13339723408694915, 0.9574635065237797, 0.8149968377125104, 0.12997839321044324], [0.14467723173737834, 0.1327221075281273, 0.2750435157159411, 0.06106304417268327]], [[0.9163440024478942, 0.21428906478440846, 0.6894155773738542, 0.6751612279093356], [0.29511969374178804, 0.11568943040607904, 0.32596884148848015, 0.9537932945409335], [0.6708895914632708, 0.8346295524244489, 0.21707919011589005, 0.14509870246259016]]], [[[0.3361158554518662, 0.838602001020879, 0.8520665989089473, 0.30012919469780885], [0.9734924655326161, 0.7647787217669181, 0.34815949319209394, 0.34318362958021953], [0.31917662712988804, 0.6256910108499081, 0.7498603661227391, 0.5580523841250132]], [[0.28899718364899596, 0.648020666539341, 0.7102451804425935, 0.3019210722641553], [0.20501813980520156, 0.6712331681288656, 0.927304593813167, 0.3750259080970749], [0.07315463714671933, 0.37788062980801895, 0.3300656776241899, 0.23522476925820313]]]] ,numpy.float_)
85346          arg = Data(val,w_arg)
85347          res=interpolate(arg,where=w_ref)
85348          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85349          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85350          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
85351          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85352       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onFunctionOnContactZero_rank0(self):
85353          """
85354          test interploation of constant rank 0 Data on ReducedFunctionOnContactZero
85355          """
85356          w_ref = ReducedFunctionOnContactZero(self.domain)
85357          w_arg = FunctionOnContactZero(self.domain)
85358          val = 4.845049e-01
85359          arg = Data(val,(),w_arg)
85360          res=interpolate(arg,where=w_ref)
85361          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85362          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85363          self.assertEqual(res.getShape(),(),"wrong shape of result.")
85364          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85365       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onFunctionOnContactZero_rank1(self):
85366          """
85367          test interploation of constant rank 1 Data on ReducedFunctionOnContactZero
85368          """
85369          w_ref = ReducedFunctionOnContactZero(self.domain)
85370          w_arg = FunctionOnContactZero(self.domain)
85371          val = numpy.array([0.6659190337943574, 0.8425843366524217, 0.86660804623725] ,numpy.float_)
85372          arg = Data(val,w_arg)
85373          res=interpolate(arg,where=w_ref)
85374          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85375          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85376          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
85377          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85378       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onFunctionOnContactZero_rank2(self):
85379          """
85380          test interploation of constant rank 2 Data on ReducedFunctionOnContactZero
85381          """
85382          w_ref = ReducedFunctionOnContactZero(self.domain)
85383          w_arg = FunctionOnContactZero(self.domain)
85384          val = numpy.array([[0.25217421622529224, 0.09102472535115458], [0.5729982223940684, 0.8740105387167216], [0.21524015232674165, 0.44837802824313044], [0.7327348938019275, 0.05221915361280771]] ,numpy.float_)
85385          arg = Data(val,w_arg)
85386          res=interpolate(arg,where=w_ref)
85387          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85388          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85389          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
85390          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85391       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onFunctionOnContactZero_rank3(self):
85392          """
85393          test interploation of constant rank 3 Data on ReducedFunctionOnContactZero
85394          """
85395          w_ref = ReducedFunctionOnContactZero(self.domain)
85396          w_arg = FunctionOnContactZero(self.domain)
85397          val = numpy.array([[[0.6799229601774239, 0.3929325398855149, 0.6847673145434182, 0.3724803911748573], [0.711887207769998, 0.22194916796210573, 0.6712549188704774, 0.28258321841582257]], [[0.7484111828715916, 0.9631433363244414, 0.7733569056267277, 0.7476954837264104], [0.45659970344320955, 0.7774148192295013, 0.21085249644732107, 0.25407762009731116]]] ,numpy.float_)
85398          arg = Data(val,w_arg)
85399          res=interpolate(arg,where=w_ref)
85400          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85401          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85402          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
85403          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85404       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onFunctionOnContactZero_rank4(self):
85405          """
85406          test interploation of constant rank 4 Data on ReducedFunctionOnContactZero
85407          """
85408          w_ref = ReducedFunctionOnContactZero(self.domain)
85409          w_arg = FunctionOnContactZero(self.domain)
85410          val = numpy.array([[[[0.21768148774428764, 0.6640555066349386, 0.593573127369806, 0.7030216681373775], [0.2655388194828342, 0.649638599701596, 0.4285054262482364, 0.20160339715342557], [0.20056970892555293, 0.5491660946360606, 0.04692162190468818, 0.4005442872519722]], [[0.16656078389952345, 0.6599981034016131, 0.037315941635561733, 0.9957549771401615], [0.04810148566846428, 0.46551096251388935, 0.6569628052537012, 0.9808626268499148], [0.39771971513048987, 0.008068708899264698, 0.1090751226259179, 0.05099323999588268]]], [[[0.04348861256016889, 0.365442326678836, 0.9414415283820283, 0.37394714916448946], [0.31486594364767595, 0.6226307984357337, 0.7214028747650802, 0.921775907496978], [0.12317126972460779, 0.1557646890316161, 0.9335148870908166, 0.7009875963822612]], [[0.553128646781664, 0.44492668999737783, 0.4667060222591197, 0.30351659012079457], [0.8317969480524376, 0.01917110870680916, 0.9940531811835266, 0.003450315454359476], [0.24015505103792256, 0.19041797883314648, 0.9014045204901404, 0.04379457314930135]]], [[[0.19618751830791958, 0.9558857598481447, 0.1462665927598613, 0.1886424867437131], [0.48965060806051286, 0.8321292490729796, 0.4151671924835313, 0.34062434911427986], [0.5365857102463347, 0.2732600262580188, 0.5158947896319159, 0.9939782588196867]], [[0.778451531491623, 0.9571672102046037, 0.7302482421416558, 0.7378134842780778], [0.38612725697484807, 0.7338263620852454, 0.8400804975696317, 0.42841324502886136], [0.35932744228731806, 0.31504182302593486, 0.7663613791571788, 0.9781536043256535]]]] ,numpy.float_)
85411          arg = Data(val,w_arg)
85412          res=interpolate(arg,where=w_ref)
85413          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85414          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85415          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
85416          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85417       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onFunctionOnContactOne_rank0(self):
85418          """
85419          test interploation of constant rank 0 Data on ReducedFunctionOnContactZero
85420          """
85421          w_ref = ReducedFunctionOnContactZero(self.domain)
85422          w_arg = FunctionOnContactOne(self.domain)
85423          val = 5.724791e-01
85424          arg = Data(val,(),w_arg)
85425          res=interpolate(arg,where=w_ref)
85426          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85427          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85428          self.assertEqual(res.getShape(),(),"wrong shape of result.")
85429          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85430       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onFunctionOnContactOne_rank1(self):
85431          """
85432          test interploation of constant rank 1 Data on ReducedFunctionOnContactZero
85433          """
85434          w_ref = ReducedFunctionOnContactZero(self.domain)
85435          w_arg = FunctionOnContactOne(self.domain)
85436          val = numpy.array([0.5698368155523524, 0.5011314959919055, 0.32171099261248726] ,numpy.float_)
85437          arg = Data(val,w_arg)
85438          res=interpolate(arg,where=w_ref)
85439          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85440          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85441          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
85442          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85443       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onFunctionOnContactOne_rank2(self):
85444          """
85445          test interploation of constant rank 2 Data on ReducedFunctionOnContactZero
85446          """
85447          w_ref = ReducedFunctionOnContactZero(self.domain)
85448          w_arg = FunctionOnContactOne(self.domain)
85449          val = numpy.array([[0.9238376342878144, 0.9999212701723688], [0.9221935327868198, 0.8690211330196875], [0.3981760585605262, 0.3799044077748108], [0.14232892443529388, 0.31344836746195603]] ,numpy.float_)
85450          arg = Data(val,w_arg)
85451          res=interpolate(arg,where=w_ref)
85452          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85453          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85454          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
85455          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85456       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onFunctionOnContactOne_rank3(self):
85457          """
85458          test interploation of constant rank 3 Data on ReducedFunctionOnContactZero
85459          """
85460          w_ref = ReducedFunctionOnContactZero(self.domain)
85461          w_arg = FunctionOnContactOne(self.domain)
85462          val = numpy.array([[[0.06056382123169868, 0.359817046935317, 0.28381043003603423, 0.4816695237021398], [0.9241695552382608, 0.22045482375842562, 0.9939653621100799, 0.31314176920992887]], [[0.3817408616497908, 0.22369390831913782, 0.527385528624288, 0.22576418268348042], [0.26244996773731366, 0.11697331204136951, 0.7509837159079806, 0.9346177813221138]]] ,numpy.float_)
85463          arg = Data(val,w_arg)
85464          res=interpolate(arg,where=w_ref)
85465          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85466          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85467          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
85468          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85469       def test_interpolate_onReducedFunctionOnContactZero_fromConstant_onFunctionOnContactOne_rank4(self):
85470          """
85471          test interploation of constant rank 4 Data on ReducedFunctionOnContactZero
85472          """
85473          w_ref = ReducedFunctionOnContactZero(self.domain)
85474          w_arg = FunctionOnContactOne(self.domain)
85475          val = numpy.array([[[[0.9611056473977208, 0.9625252433932414, 0.9701210392672508, 0.7392339432713271], [0.8125183894981813, 0.20490337916335266, 0.5313678844562993, 0.7502017282131984], [0.6560708268845925, 0.17454924487736734, 0.7687959897406307, 0.9565415557844211]], [[0.8944855699395525, 0.7792395779626226, 0.8708531279970064, 0.9620073237823549], [0.8838912214913078, 0.5215520015606976, 0.5586945994230323, 0.921579825455942], [0.6301087631520504, 0.035212743170049965, 0.5389854926876433, 0.29091508887432127]]], [[[0.3297109672452041, 0.9339653472582714, 0.3259050675319838, 0.9314065435929958], [0.4429931962783342, 0.23694021826557976, 0.12858004366485876, 0.6882459597499574], [0.08209003947879734, 0.9960079105665074, 0.2841255462316885, 0.5592870479239467]], [[0.8418287665306695, 0.9432765765026192, 0.6551290626281849, 0.44728268160156304], [0.21151964485242125, 0.1833556472481973, 0.07247562741733071, 0.005213331928283549], [0.9838906601539259, 0.04065411088930826, 0.7965971010299203, 0.7068566837958828]]], [[[0.2073063316702618, 0.5503845897620818, 0.6989624559798674, 0.8464504221293961], [0.0761415094247948, 0.6427663541749622, 0.6114978020573574, 0.38368907229409777], [0.6624151078407227, 0.40744011855276563, 0.9943285398742499, 0.7130099498829475]], [[0.9333858863734091, 0.8705579491142914, 0.7183669180540276, 0.5336980442576607], [0.722637631155766, 0.15914988496070648, 0.609464425883208, 0.8625554848316861], [0.6003406314835725, 0.5169900024490881, 0.4111695760667604, 0.8117933242175697]]]] ,numpy.float_)
85476          arg = Data(val,w_arg)
85477          res=interpolate(arg,where=w_ref)
85478          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85479          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85480          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
85481          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85482       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onSolution_rank0(self):
85483          """
85484          test interploation of constant rank 0 Data on ReducedFunctionOnContactOne
85485          """
85486          w_ref = ReducedFunctionOnContactOne(self.domain)
85487          w_arg = Solution(self.domain)
85488          val = 2.329112e-01
85489          arg = Data(val,(),w_arg)
85490          res=interpolate(arg,where=w_ref)
85491          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85492          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85493          self.assertEqual(res.getShape(),(),"wrong shape of result.")
85494          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85495       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onSolution_rank1(self):
85496          """
85497          test interploation of constant rank 1 Data on ReducedFunctionOnContactOne
85498          """
85499          w_ref = ReducedFunctionOnContactOne(self.domain)
85500          w_arg = Solution(self.domain)
85501          val = numpy.array([0.2711886947991414, 0.8151355217815176, 0.548802974879618] ,numpy.float_)
85502          arg = Data(val,w_arg)
85503          res=interpolate(arg,where=w_ref)
85504          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85505          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85506          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
85507          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85508       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onSolution_rank2(self):
85509          """
85510          test interploation of constant rank 2 Data on ReducedFunctionOnContactOne
85511          """
85512          w_ref = ReducedFunctionOnContactOne(self.domain)
85513          w_arg = Solution(self.domain)
85514          val = numpy.array([[0.8570748126811828, 0.6716856327358565], [0.21482736306984695, 0.06808127712181944], [0.9612468983613089, 0.28244457685273383], [0.7948157169365453, 0.6984681635200359]] ,numpy.float_)
85515          arg = Data(val,w_arg)
85516          res=interpolate(arg,where=w_ref)
85517          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85518          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85519          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
85520          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85521       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onSolution_rank3(self):
85522          """
85523          test interploation of constant rank 3 Data on ReducedFunctionOnContactOne
85524          """
85525          w_ref = ReducedFunctionOnContactOne(self.domain)
85526          w_arg = Solution(self.domain)
85527          val = numpy.array([[[0.45165079289227006, 0.6289081084686083, 0.0026816585529017, 0.6272694446815826], [0.3010372661670382, 0.41395307175135165, 0.6042854301060929, 0.5142571738122232]], [[0.5008637439715871, 0.9353749115529721, 0.8461283387858052, 0.7786733015801677], [0.5645640680484281, 0.029207927788641452, 0.9245927728277314, 0.11215605749828972]]] ,numpy.float_)
85528          arg = Data(val,w_arg)
85529          res=interpolate(arg,where=w_ref)
85530          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85531          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85532          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
85533          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85534       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onSolution_rank4(self):
85535          """
85536          test interploation of constant rank 4 Data on ReducedFunctionOnContactOne
85537          """
85538          w_ref = ReducedFunctionOnContactOne(self.domain)
85539          w_arg = Solution(self.domain)
85540          val = numpy.array([[[[0.6667443235973334, 0.5942110361407772, 0.912954606463574, 0.2561427231087743], [0.03600309973338811, 0.5268165160971201, 0.867185955246074, 0.1239484471139769], [0.44253560243971357, 0.43847765297702945, 0.7821567693309968, 0.43443532577956356]], [[0.3984396145874014, 0.38981536734729494, 0.1087483198166681, 0.31180401854591444], [0.889056982006137, 0.48548744067116734, 0.906615382695575, 0.3407086005104446], [0.9198134373422651, 0.9231091093031504, 0.1270515255589374, 0.5067823228534746]]], [[[0.3617513525269881, 0.9574600969184808, 0.11483159594978753, 0.45717952457785926], [0.6916384030503141, 0.047365934376841334, 0.3084139015584185, 0.34364384139996695], [0.05537078077656177, 0.7810234521541862, 0.7306151948170092, 0.7704150321221694]], [[0.784746089405918, 0.8707184031358675, 0.47187684294608834, 0.9226435647241911], [0.6589102270951339, 0.9003100870465465, 0.4302446269703575, 0.8289555515035888], [0.36657797042557505, 0.3740237638520778, 0.9241858074329256, 0.20129929703134763]]], [[[0.032220216298067705, 0.9702497099141327, 0.15627179451850504, 0.5276175837577495], [0.679992562773294, 0.3937022020883134, 0.39634005303659947, 0.08166191158104608], [0.489219423966899, 0.1139517718170946, 0.2190339095220224, 0.7646487210991467]], [[0.6907510516138318, 0.5855936531863534, 0.5457891503259775, 0.34046708951156646], [0.9954466744953929, 0.7578070949471264, 0.05861984555028843, 0.4050603537075873], [0.3839626297766049, 0.45543971152592133, 0.6354353285261648, 0.5529225073133225]]]] ,numpy.float_)
85541          arg = Data(val,w_arg)
85542          res=interpolate(arg,where=w_ref)
85543          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85544          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85545          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
85546          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85547       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onReducedSolution_rank0(self):
85548          """
85549          test interploation of constant rank 0 Data on ReducedFunctionOnContactOne
85550          """
85551          w_ref = ReducedFunctionOnContactOne(self.domain)
85552          w_arg = ReducedSolution(self.domain)
85553          val = 1.264995e-01
85554          arg = Data(val,(),w_arg)
85555          res=interpolate(arg,where=w_ref)
85556          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85557          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85558          self.assertEqual(res.getShape(),(),"wrong shape of result.")
85559          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85560       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onReducedSolution_rank1(self):
85561          """
85562          test interploation of constant rank 1 Data on ReducedFunctionOnContactOne
85563          """
85564          w_ref = ReducedFunctionOnContactOne(self.domain)
85565          w_arg = ReducedSolution(self.domain)
85566          val = numpy.array([0.00606243243505622, 0.873034020260163, 0.6841164021678631] ,numpy.float_)
85567          arg = Data(val,w_arg)
85568          res=interpolate(arg,where=w_ref)
85569          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85570          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85571          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
85572          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85573       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onReducedSolution_rank2(self):
85574          """
85575          test interploation of constant rank 2 Data on ReducedFunctionOnContactOne
85576          """
85577          w_ref = ReducedFunctionOnContactOne(self.domain)
85578          w_arg = ReducedSolution(self.domain)
85579          val = numpy.array([[0.31093865621812533, 0.39058400322997067], [0.1567669755282769, 0.03514071146133979], [0.9500533629353507, 0.948835882084125], [0.939378083220056, 0.5099242977624797]] ,numpy.float_)
85580          arg = Data(val,w_arg)
85581          res=interpolate(arg,where=w_ref)
85582          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85583          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85584          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
85585          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85586       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onReducedSolution_rank3(self):
85587          """
85588          test interploation of constant rank 3 Data on ReducedFunctionOnContactOne
85589          """
85590          w_ref = ReducedFunctionOnContactOne(self.domain)
85591          w_arg = ReducedSolution(self.domain)
85592          val = numpy.array([[[0.45007016486443874, 0.6124223809428949, 0.7119569531022489, 0.9442018514201687], [0.36356781159602614, 0.27723610150765865, 0.7946173432983135, 0.9092945948072412]], [[0.1759860846095892, 0.6678468246950318, 0.17838954927513861, 0.8153494705492041], [0.9824334501398573, 0.900923805295426, 0.4704772535790611, 0.9921140597526442]]] ,numpy.float_)
85593          arg = Data(val,w_arg)
85594          res=interpolate(arg,where=w_ref)
85595          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85596          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85597          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
85598          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85599       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onReducedSolution_rank4(self):
85600          """
85601          test interploation of constant rank 4 Data on ReducedFunctionOnContactOne
85602          """
85603          w_ref = ReducedFunctionOnContactOne(self.domain)
85604          w_arg = ReducedSolution(self.domain)
85605          val = numpy.array([[[[0.11855174064114682, 0.1451392781947035, 0.6160462460663021, 0.9435709224990018], [0.5778251588350022, 0.35345122476635427, 0.15737472936970198, 0.5068053965783152], [0.6496370130999982, 0.7565725953485603, 0.8877311648144324, 0.6779183819088433]], [[0.19499210597476802, 0.05963196379949376, 0.8471924161676365, 0.6796323912421396], [0.6879746956169507, 0.31493633190401105, 0.10395651021404007, 0.7566677619630795], [0.8219461421678597, 0.7427790065801423, 0.4898599644283754, 0.09731680329940562]]], [[[0.8578179515616177, 0.017653922457677496, 0.5920299881752641, 0.6540800346765566], [0.08108154104941678, 0.5492952546810023, 0.327341995902085, 0.008431680039213907], [0.43869582655314643, 0.5031428199029038, 0.23772964965025756, 0.56411232787934]], [[0.8338427483017984, 0.2784845639882001, 0.684750809513023, 0.5771865103410377], [0.5383837799814473, 0.4326295086578277, 0.5415153722697578, 0.42890048909447354], [0.9176178153213768, 0.3097673125495437, 0.029148740941863593, 0.5698778269902484]]], [[[0.6199790422663453, 0.5454395501524304, 0.2559067601655193, 0.3723918906555914], [0.43061378209477463, 0.5209802274257546, 0.9632587198410986, 0.7212958354714519], [0.0026623677260552148, 0.8128428713463965, 0.9704429257805324, 0.7749663740105225]], [[0.28521348143121894, 0.04008708758840007, 0.2304032047764707, 0.14563590389591285], [0.9271821441390897, 0.5912086707216369, 0.6719091239917508, 0.07848234072199611], [0.39376430262958106, 0.15375603049356268, 0.1955391476314452, 0.610816803461706]]]] ,numpy.float_)
85606          arg = Data(val,w_arg)
85607          res=interpolate(arg,where=w_ref)
85608          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85609          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85610          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
85611          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85612       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onContinuousFunction_rank0(self):
85613          """
85614          test interploation of constant rank 0 Data on ReducedFunctionOnContactOne
85615          """
85616          w_ref = ReducedFunctionOnContactOne(self.domain)
85617          w_arg = ContinuousFunction(self.domain)
85618          val = 5.179575e-01
85619          arg = Data(val,(),w_arg)
85620          res=interpolate(arg,where=w_ref)
85621          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85622          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85623          self.assertEqual(res.getShape(),(),"wrong shape of result.")
85624          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85625       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onContinuousFunction_rank1(self):
85626          """
85627          test interploation of constant rank 1 Data on ReducedFunctionOnContactOne
85628          """
85629          w_ref = ReducedFunctionOnContactOne(self.domain)
85630          w_arg = ContinuousFunction(self.domain)
85631          val = numpy.array([0.9575768192361481, 0.9644800915878442, 0.23982841164781] ,numpy.float_)
85632          arg = Data(val,w_arg)
85633          res=interpolate(arg,where=w_ref)
85634          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85635          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85636          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
85637          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85638       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onContinuousFunction_rank2(self):
85639          """
85640          test interploation of constant rank 2 Data on ReducedFunctionOnContactOne
85641          """
85642          w_ref = ReducedFunctionOnContactOne(self.domain)
85643          w_arg = ContinuousFunction(self.domain)
85644          val = numpy.array([[0.9718619518517126, 0.6327758010877947], [0.358183029640899, 0.6439584235904635], [0.01076934009736974, 0.3920209701539201], [0.3271826942675151, 0.12500826265093368]] ,numpy.float_)
85645          arg = Data(val,w_arg)
85646          res=interpolate(arg,where=w_ref)
85647          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85648          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85649          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
85650          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85651       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onContinuousFunction_rank3(self):
85652          """
85653          test interploation of constant rank 3 Data on ReducedFunctionOnContactOne
85654          """
85655          w_ref = ReducedFunctionOnContactOne(self.domain)
85656          w_arg = ContinuousFunction(self.domain)
85657          val = numpy.array([[[0.23389693596510674, 0.34876444091356096, 0.08744141097388891, 0.4860415807991585], [0.908103324472909, 0.4876573256899095, 0.7320153900343996, 0.27328200078230325]], [[0.2885358653030069, 0.8225359508790787, 0.3719228117362148, 0.8599909728511795], [0.07608006606226236, 0.3585371367277932, 0.9832606683200212, 0.4231855648978766]]] ,numpy.float_)
85658          arg = Data(val,w_arg)
85659          res=interpolate(arg,where=w_ref)
85660          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85661          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85662          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
85663          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85664       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onContinuousFunction_rank4(self):
85665          """
85666          test interploation of constant rank 4 Data on ReducedFunctionOnContactOne
85667          """
85668          w_ref = ReducedFunctionOnContactOne(self.domain)
85669          w_arg = ContinuousFunction(self.domain)
85670          val = numpy.array([[[[0.818535980265798, 0.6156101394672567, 0.9411922390783354, 0.26268772801813944], [0.19860764368424977, 0.06682526098172914, 0.5729195351645129, 0.7939987998645818], [0.45296785676428875, 0.3574723572222631, 0.05507517619000457, 0.37615849163587134]], [[0.24889441716570793, 0.8269423706543342, 0.8689218475567405, 0.862901595496822], [0.5113018931092743, 0.4729113909263415, 0.8640787989842668, 0.6144202571856222], [0.059352354383009454, 0.8841351505399457, 0.4655495168602738, 0.04588429517329806]]], [[[0.9976406856864566, 0.19979008945652021, 0.37575561777196065, 0.5114301121118882], [0.5087730755067255, 0.7445349695232956, 0.20158996669666251, 0.17416591891247846], [0.626996463374618, 0.4717095353175206, 0.4127681790678299, 0.2267064023100076]], [[0.9797121620388637, 0.2506646833379459, 0.27849080014984273, 0.10827692144418677], [0.9282022116283123, 0.463766999230508, 0.5036225568963277, 0.6711495953323894], [0.8734368271422581, 0.3482094575282234, 0.5495193518240209, 0.3423976284311623]]], [[[0.14344456903470693, 0.4018605515532431, 0.3045836878855571, 0.7619929766169216], [0.7863650744050896, 0.3215891898594264, 0.9390648313351854, 0.6492326307978694], [0.2796544369091747, 0.8007304655227839, 0.42333187150567964, 0.09960921173211457]], [[0.4679857067545191, 0.4006626029265893, 0.24884973672213073, 0.52548623594872], [0.7537325455397446, 0.2631311984677541, 0.24602201916926036, 0.9387862828976604], [0.7387343021186891, 0.960930261846333, 0.22593033956112607, 0.834975286046687]]]] ,numpy.float_)
85671          arg = Data(val,w_arg)
85672          res=interpolate(arg,where=w_ref)
85673          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85674          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85675          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
85676          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85677       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onReducedContinuousFunction_rank0(self):
85678          """
85679          test interploation of constant rank 0 Data on ReducedFunctionOnContactOne
85680          """
85681          w_ref = ReducedFunctionOnContactOne(self.domain)
85682          w_arg = ReducedContinuousFunction(self.domain)
85683          val = 3.875819e-01
85684          arg = Data(val,(),w_arg)
85685          res=interpolate(arg,where=w_ref)
85686          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85687          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85688          self.assertEqual(res.getShape(),(),"wrong shape of result.")
85689          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85690       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onReducedContinuousFunction_rank1(self):
85691          """
85692          test interploation of constant rank 1 Data on ReducedFunctionOnContactOne
85693          """
85694          w_ref = ReducedFunctionOnContactOne(self.domain)
85695          w_arg = ReducedContinuousFunction(self.domain)
85696          val = numpy.array([0.18278843949565338, 0.03443967023834149, 0.004760660997311761] ,numpy.float_)
85697          arg = Data(val,w_arg)
85698          res=interpolate(arg,where=w_ref)
85699          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85700          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85701          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
85702          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85703       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onReducedContinuousFunction_rank2(self):
85704          """
85705          test interploation of constant rank 2 Data on ReducedFunctionOnContactOne
85706          """
85707          w_ref = ReducedFunctionOnContactOne(self.domain)
85708          w_arg = ReducedContinuousFunction(self.domain)
85709          val = numpy.array([[0.2578876581313929, 0.1138047786434172], [0.2542456971866308, 0.13941180663674912], [0.3216905040850888, 0.6388738438409454], [0.6135317788608333, 0.28093463385456574]] ,numpy.float_)
85710          arg = Data(val,w_arg)
85711          res=interpolate(arg,where=w_ref)
85712          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85713          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85714          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
85715          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85716       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onReducedContinuousFunction_rank3(self):
85717          """
85718          test interploation of constant rank 3 Data on ReducedFunctionOnContactOne
85719          """
85720          w_ref = ReducedFunctionOnContactOne(self.domain)
85721          w_arg = ReducedContinuousFunction(self.domain)
85722          val = numpy.array([[[0.199315997451887, 0.45486284065809934, 0.405439889990851, 0.29442748313818545], [0.26863720801322866, 0.17106342510663386, 0.9508530974979329, 0.2883315892815461]], [[0.7952214446491916, 0.9355296046333761, 0.5338441039561624, 0.02321050156131721], [0.09269655172112112, 0.994349126977387, 0.062363748803044405, 0.703105591771991]]] ,numpy.float_)
85723          arg = Data(val,w_arg)
85724          res=interpolate(arg,where=w_ref)
85725          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85726          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85727          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
85728          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85729       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onReducedContinuousFunction_rank4(self):
85730          """
85731          test interploation of constant rank 4 Data on ReducedFunctionOnContactOne
85732          """
85733          w_ref = ReducedFunctionOnContactOne(self.domain)
85734          w_arg = ReducedContinuousFunction(self.domain)
85735          val = numpy.array([[[[0.27195814824192577, 0.029726316922277896, 0.49277870766075105, 0.6882715721882958], [0.06530184102907244, 0.3107327502824384, 0.3250986030626254, 0.5322683855671014], [0.9999187287127889, 0.04262557739347317, 0.47022418238457353, 0.5979396856062474]], [[0.5375737583080935, 0.6972017617080326, 0.4860487017535191, 0.5746615797843607], [0.081808161048184, 0.19623554896756146, 0.7644374545278538, 0.4558595129288673], [0.027786048701642918, 0.880508951040538, 0.8454412050462895, 0.7035264702988474]]], [[[0.06264870669390299, 0.9992877495547031, 0.6237397672951204, 0.11013805728287651], [0.11659585486148294, 0.7721732639128884, 0.12789435384035763, 0.8719995775452345], [0.6235605837278547, 0.8881807315866083, 0.6847908121857974, 0.9536927911310386]], [[0.7475667499188174, 0.17340704220159198, 0.9377964314689402, 0.2619685096798563], [0.11142872847409657, 0.372971012113405, 0.5717009335101155, 0.3046912409554343], [0.45706794587981936, 0.7074317314588832, 0.5229389820159638, 0.9345077481625098]]], [[[0.24417132911143768, 0.6103183235574506, 0.2150951867132428, 0.10646173490686373], [0.3181942631910315, 0.6191198150724172, 0.35592507092630776, 0.9273583808730407], [0.19175170549128606, 0.9483615422865661, 0.00693853046549997, 0.16967301609688423]], [[0.3668426329153802, 0.539203966787359, 0.4097258359307496, 0.5090384595876427], [0.38135386133641624, 0.9141255977853077, 0.19462182339311707, 0.017402039812049686], [0.10747602911816012, 0.5265530738832295, 0.5693492483053987, 0.15872280601063737]]]] ,numpy.float_)
85736          arg = Data(val,w_arg)
85737          res=interpolate(arg,where=w_ref)
85738          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85739          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85740          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
85741          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85742       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onReducedFunctionOnContactZero_rank0(self):
85743          """
85744          test interploation of constant rank 0 Data on ReducedFunctionOnContactOne
85745          """
85746          w_ref = ReducedFunctionOnContactOne(self.domain)
85747          w_arg = ReducedFunctionOnContactZero(self.domain)
85748          val = 7.955394e-01
85749          arg = Data(val,(),w_arg)
85750          res=interpolate(arg,where=w_ref)
85751          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85752          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85753          self.assertEqual(res.getShape(),(),"wrong shape of result.")
85754          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85755       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onReducedFunctionOnContactZero_rank1(self):
85756          """
85757          test interploation of constant rank 1 Data on ReducedFunctionOnContactOne
85758          """
85759          w_ref = ReducedFunctionOnContactOne(self.domain)
85760          w_arg = ReducedFunctionOnContactZero(self.domain)
85761          val = numpy.array([0.03765147921520662, 0.2859074148555407, 0.8652615609153638] ,numpy.float_)
85762          arg = Data(val,w_arg)
85763          res=interpolate(arg,where=w_ref)
85764          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85765          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85766          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
85767          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85768       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onReducedFunctionOnContactZero_rank2(self):
85769          """
85770          test interploation of constant rank 2 Data on ReducedFunctionOnContactOne
85771          """
85772          w_ref = ReducedFunctionOnContactOne(self.domain)
85773          w_arg = ReducedFunctionOnContactZero(self.domain)
85774          val = numpy.array([[0.36341448566303136, 0.17964069584166464], [0.356752488191608, 0.46543665302504234], [0.7406980183987848, 0.9808612211679858], [0.7644979900921803, 0.5266073649506665]] ,numpy.float_)
85775          arg = Data(val,w_arg)
85776          res=interpolate(arg,where=w_ref)
85777          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85778          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85779          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
85780          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85781       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onReducedFunctionOnContactZero_rank3(self):
85782          """
85783          test interploation of constant rank 3 Data on ReducedFunctionOnContactOne
85784          """
85785          w_ref = ReducedFunctionOnContactOne(self.domain)
85786          w_arg = ReducedFunctionOnContactZero(self.domain)
85787          val = numpy.array([[[0.7870982948344794, 0.11262360158133167, 0.21737213085331708, 0.01180789807172311], [0.49899743378700356, 0.10070842951855086, 0.6307896822003546, 0.13868983966975845]], [[0.7455103088049124, 0.534381249407766, 0.31885226909664643, 0.5252376541572474], [0.5434115143323359, 0.44547596461106564, 0.36893165457783017, 0.3068600727665063]]] ,numpy.float_)
85788          arg = Data(val,w_arg)
85789          res=interpolate(arg,where=w_ref)
85790          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85791          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85792          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
85793          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85794       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onReducedFunctionOnContactZero_rank4(self):
85795          """
85796          test interploation of constant rank 4 Data on ReducedFunctionOnContactOne
85797          """
85798          w_ref = ReducedFunctionOnContactOne(self.domain)
85799          w_arg = ReducedFunctionOnContactZero(self.domain)
85800          val = numpy.array([[[[0.8189704356276197, 0.3749050832248578, 0.27389450562415263, 0.5383418333545886], [0.21503535733189094, 0.1330764764687099, 0.23537866042369227, 0.08439743856859616], [0.25695331975720415, 0.1611568135103344, 0.2120386564651976, 0.2759536169148714]], [[0.21258951350562738, 0.8613499384201753, 0.47317365415525503, 0.7355470830751574], [0.9894693607386535, 0.4657250277922349, 0.7367602483666915, 0.18317427209088943], [0.32843011883353856, 0.0012833284516546861, 0.11094884486888767, 0.06499518950184302]]], [[[0.1589764113768818, 0.5424115098290392, 0.5756546771331035, 0.5891081919596415], [0.9971395232800137, 0.5127953175775566, 0.9493819905561655, 0.7617398358785147], [0.9553688130117116, 0.22687512684115074, 0.5001452046414812, 0.688567440068334]], [[0.5918445549691579, 0.2967613273527532, 0.5601946369187094, 0.3399745963621382], [0.8780144653070053, 0.6966757894030086, 0.6500925389906903, 0.9917461476498427], [0.5108217455443833, 0.6330537789188553, 0.4617614480677317, 0.25943269372998146]]], [[[0.2813712889523716, 0.8022918169474674, 0.6790872615412888, 0.7551331928170524], [0.8951817149895257, 0.9257445233242998, 0.7409626782849315, 0.5222813180591156], [0.7954260297545448, 0.9643852812336107, 0.7876470759398919, 0.4702114267889068]], [[0.9020950849353047, 0.7488231531166031, 0.12645975496382733, 0.8684049309189978], [0.5665838087497248, 0.6346594570923372, 0.6834979216607802, 0.970333455895161], [0.4172392831795092, 0.7619652663623792, 0.8219136442872614, 0.11204388928270648]]]] ,numpy.float_)
85801          arg = Data(val,w_arg)
85802          res=interpolate(arg,where=w_ref)
85803          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85804          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85805          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
85806          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85807       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onReducedFunctionOnContactOne_rank0(self):
85808          """
85809          test interploation of constant rank 0 Data on ReducedFunctionOnContactOne
85810          """
85811          w_ref = ReducedFunctionOnContactOne(self.domain)
85812          w_arg = ReducedFunctionOnContactOne(self.domain)
85813          val = 8.306100e-01
85814          arg = Data(val,(),w_arg)
85815          res=interpolate(arg,where=w_ref)
85816          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85817          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85818          self.assertEqual(res.getShape(),(),"wrong shape of result.")
85819          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85820       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onReducedFunctionOnContactOne_rank1(self):
85821          """
85822          test interploation of constant rank 1 Data on ReducedFunctionOnContactOne
85823          """
85824          w_ref = ReducedFunctionOnContactOne(self.domain)
85825          w_arg = ReducedFunctionOnContactOne(self.domain)
85826          val = numpy.array([0.8126865327966136, 0.9829268967367245, 0.20673602560938897] ,numpy.float_)
85827          arg = Data(val,w_arg)
85828          res=interpolate(arg,where=w_ref)
85829          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85830          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85831          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
85832          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85833       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onReducedFunctionOnContactOne_rank2(self):
85834          """
85835          test interploation of constant rank 2 Data on ReducedFunctionOnContactOne
85836          """
85837          w_ref = ReducedFunctionOnContactOne(self.domain)
85838          w_arg = ReducedFunctionOnContactOne(self.domain)
85839          val = numpy.array([[0.35008005617383176, 0.8142512701460992], [0.45103962710001466, 0.0424878627433154], [0.5343025439071445, 0.33656728140986336], [0.21703155524253026, 0.9737966724769462]] ,numpy.float_)
85840          arg = Data(val,w_arg)
85841          res=interpolate(arg,where=w_ref)
85842          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85843          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85844          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
85845          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85846       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onReducedFunctionOnContactOne_rank3(self):
85847          """
85848          test interploation of constant rank 3 Data on ReducedFunctionOnContactOne
85849          """
85850          w_ref = ReducedFunctionOnContactOne(self.domain)
85851          w_arg = ReducedFunctionOnContactOne(self.domain)
85852          val = numpy.array([[[0.6178796961055507, 0.2693940062385778, 0.11788134151880392, 0.9743629728341656], [0.4586535139254899, 0.6020370252232854, 0.37269584333047734, 0.9587587193475751]], [[0.7282684231616958, 0.5293756930533948, 0.8154839499936752, 0.030517350536140797], [0.07446755618228962, 0.9959175880156744, 0.8685115095234088, 0.9444178438621647]]] ,numpy.float_)
85853          arg = Data(val,w_arg)
85854          res=interpolate(arg,where=w_ref)
85855          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85856          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85857          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
85858          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85859       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onReducedFunctionOnContactOne_rank4(self):
85860          """
85861          test interploation of constant rank 4 Data on ReducedFunctionOnContactOne
85862          """
85863          w_ref = ReducedFunctionOnContactOne(self.domain)
85864          w_arg = ReducedFunctionOnContactOne(self.domain)
85865          val = numpy.array([[[[0.8229293340116391, 0.04456583018757365, 0.6715510688742183, 0.8910519958413956], [0.19894162523286274, 0.4552004293501739, 0.7233022966267526, 0.6399722753245947], [0.2183475810904214, 0.030019934703234386, 0.4559960877367557, 0.790602623163557]], [[0.23517742840085265, 0.86099844962103, 0.41449046709133874, 0.7974807011831332], [0.09498631833081073, 0.6969597482520815, 0.1655532927738047, 0.0012090022895088204], [0.3679632949225038, 0.8073400302714234, 0.06002516215853826, 0.13965166901741777]]], [[[0.805510627229193, 0.6641922758413422, 0.907076465037853, 0.609870550901237], [0.3549098061568603, 0.44333040318254247, 0.9941570771095157, 0.8857533103519696], [0.7460339094785616, 0.3546039138396384, 0.6868416067314108, 0.21085851968104685]], [[0.24325335870791442, 0.7587127481051399, 0.7399607443828173, 0.4719188132354729], [0.7684370047303896, 0.7074337577840932, 0.8311949866565859, 0.4281633523538112], [0.6496731595028286, 0.3157488953129065, 0.41456560304268386, 0.9990573393495944]]], [[[0.8591204685291776, 0.11832932081662917, 0.9954904508141627, 0.8274744901031881], [0.876832009144863, 0.18439293339631913, 0.9225427810054083, 0.9030760584934312], [0.8545293219699139, 0.7383696332456177, 0.5093167813355622, 0.2180258648280875]], [[0.9123825889878454, 0.894749826362633, 0.7911943997179549, 0.3490818123417232], [0.33556337999303076, 0.7128501122208191, 0.6593788805767017, 0.4140054483336142], [0.30654568343166866, 0.36240259803332264, 0.5521850257261249, 0.2572440770617319]]]] ,numpy.float_)
85866          arg = Data(val,w_arg)
85867          res=interpolate(arg,where=w_ref)
85868          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85869          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85870          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
85871          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85872       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onFunctionOnContactZero_rank0(self):
85873          """
85874          test interploation of constant rank 0 Data on ReducedFunctionOnContactOne
85875          """
85876          w_ref = ReducedFunctionOnContactOne(self.domain)
85877          w_arg = FunctionOnContactZero(self.domain)
85878          val = 8.572442e-02
85879          arg = Data(val,(),w_arg)
85880          res=interpolate(arg,where=w_ref)
85881          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85882          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85883          self.assertEqual(res.getShape(),(),"wrong shape of result.")
85884          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85885       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onFunctionOnContactZero_rank1(self):
85886          """
85887          test interploation of constant rank 1 Data on ReducedFunctionOnContactOne
85888          """
85889          w_ref = ReducedFunctionOnContactOne(self.domain)
85890          w_arg = FunctionOnContactZero(self.domain)
85891          val = numpy.array([0.6339958903951071, 0.3834031163077566, 0.28960145769538304] ,numpy.float_)
85892          arg = Data(val,w_arg)
85893          res=interpolate(arg,where=w_ref)
85894          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85895          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85896          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
85897          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85898       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onFunctionOnContactZero_rank2(self):
85899          """
85900          test interploation of constant rank 2 Data on ReducedFunctionOnContactOne
85901          """
85902          w_ref = ReducedFunctionOnContactOne(self.domain)
85903          w_arg = FunctionOnContactZero(self.domain)
85904          val = numpy.array([[0.30281019536341214, 0.4061960862960112], [0.9469282733503931, 0.7211459631770277], [0.7915727058455629, 0.00531635681177367], [0.23027833431083422, 0.24603244345161057]] ,numpy.float_)
85905          arg = Data(val,w_arg)
85906          res=interpolate(arg,where=w_ref)
85907          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85908          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85909          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
85910          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85911       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onFunctionOnContactZero_rank3(self):
85912          """
85913          test interploation of constant rank 3 Data on ReducedFunctionOnContactOne
85914          """
85915          w_ref = ReducedFunctionOnContactOne(self.domain)
85916          w_arg = FunctionOnContactZero(self.domain)
85917          val = numpy.array([[[0.23230818858420033, 0.546564545487729, 0.32266159961977714, 0.603316962320113], [0.2961725195272631, 0.43933328167426966, 0.844785166976214, 0.4881408035048409]], [[0.2607395253886762, 0.5423934580557075, 0.7619733519017275, 0.5812060614648623], [0.0613130772917484, 0.05223867445369368, 0.6802367998056611, 0.08920080302295674]]] ,numpy.float_)
85918          arg = Data(val,w_arg)
85919          res=interpolate(arg,where=w_ref)
85920          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85921          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85922          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
85923          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85924       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onFunctionOnContactZero_rank4(self):
85925          """
85926          test interploation of constant rank 4 Data on ReducedFunctionOnContactOne
85927          """
85928          w_ref = ReducedFunctionOnContactOne(self.domain)
85929          w_arg = FunctionOnContactZero(self.domain)
85930          val = numpy.array([[[[0.5359541100352402, 0.6492481992248392, 0.627809876175268, 0.032183035161362894], [0.6855392752408003, 0.38386506246246577, 0.6877496796830016, 0.9244294054159945], [0.779266018879794, 0.5454157741507168, 0.6076136704393503, 0.34098977241628126]], [[0.6725574014492601, 0.9924554727497924, 0.11265712415266071, 0.6509645338461001], [0.6566058880315083, 0.05085750216442875, 0.25050214797123427, 0.11913979139451825], [0.6011271462578217, 0.6240268129488139, 0.26460794633119367, 0.05733546763708264]]], [[[0.607769674684382, 0.10598819875815713, 0.8776962546840539, 0.8266601773987386], [0.8631846579822211, 0.6879685601086099, 0.1359518845716131, 0.4685454581791084], [0.3209883310787902, 0.4737321179870807, 0.6413260281499608, 0.060790725664807366]], [[0.5956883363196818, 0.07328419173849654, 0.8490340074264021, 0.12305983025717881], [0.9629571076901358, 0.8103596371491041, 0.14296043169605432, 0.8455997248569967], [0.566533587998251, 0.4079548923236669, 0.09480821134398254, 0.8453438861794155]]], [[[0.36555150410471093, 0.3009926174449653, 0.9326518297055033, 0.452395179058795], [0.045232604076099636, 0.8196996070484879, 0.4118988069767353, 0.5721464132856435], [0.1023427638050095, 0.7868280835389061, 0.25359288064036933, 0.44768371695910847]], [[0.10293864817984721, 0.43875987030641805, 0.22119598335766544, 0.5248768126420456], [0.5996872812495732, 0.07227556382845923, 0.18190141013260508, 0.6082154732630453], [0.2897180173479402, 0.17483245717532458, 0.9368027518821712, 0.416391916226614]]]] ,numpy.float_)
85931          arg = Data(val,w_arg)
85932          res=interpolate(arg,where=w_ref)
85933          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85934          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85935          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
85936          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85937       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onFunctionOnContactOne_rank0(self):
85938          """
85939          test interploation of constant rank 0 Data on ReducedFunctionOnContactOne
85940          """
85941          w_ref = ReducedFunctionOnContactOne(self.domain)
85942          w_arg = FunctionOnContactOne(self.domain)
85943          val = 5.976848e-01
85944          arg = Data(val,(),w_arg)
85945          res=interpolate(arg,where=w_ref)
85946          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85947          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85948          self.assertEqual(res.getShape(),(),"wrong shape of result.")
85949          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85950       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onFunctionOnContactOne_rank1(self):
85951          """
85952          test interploation of constant rank 1 Data on ReducedFunctionOnContactOne
85953          """
85954          w_ref = ReducedFunctionOnContactOne(self.domain)
85955          w_arg = FunctionOnContactOne(self.domain)
85956          val = numpy.array([0.9979220795470324, 0.913058303488773, 0.9238045481549146] ,numpy.float_)
85957          arg = Data(val,w_arg)
85958          res=interpolate(arg,where=w_ref)
85959          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85960          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85961          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
85962          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85963       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onFunctionOnContactOne_rank2(self):
85964          """
85965          test interploation of constant rank 2 Data on ReducedFunctionOnContactOne
85966          """
85967          w_ref = ReducedFunctionOnContactOne(self.domain)
85968          w_arg = FunctionOnContactOne(self.domain)
85969          val = numpy.array([[0.3760218998871382, 0.5495501353286991], [0.7733345507339668, 0.6655487841256854], [0.6270627445510198, 0.5850690403436837], [0.8377177857529043, 0.37950806864436704]] ,numpy.float_)
85970          arg = Data(val,w_arg)
85971          res=interpolate(arg,where=w_ref)
85972          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85973          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85974          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
85975          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85976       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onFunctionOnContactOne_rank3(self):
85977          """
85978          test interploation of constant rank 3 Data on ReducedFunctionOnContactOne
85979          """
85980          w_ref = ReducedFunctionOnContactOne(self.domain)
85981          w_arg = FunctionOnContactOne(self.domain)
85982          val = numpy.array([[[0.8125672122559341, 0.1469570456460404, 0.2593339404377025, 0.07208068660362044], [0.8069143731585875, 0.6618452104435641, 0.35155373733752715, 0.16464730345004108]], [[0.9621221120677534, 0.0765861810496069, 0.6277671674055675, 0.963676802059102], [0.10360342520174248, 0.28692024730085797, 0.987611605315119, 0.07931181270683207]]] ,numpy.float_)
85983          arg = Data(val,w_arg)
85984          res=interpolate(arg,where=w_ref)
85985          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85986          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
85987          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
85988          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
85989       def test_interpolate_onReducedFunctionOnContactOne_fromConstant_onFunctionOnContactOne_rank4(self):
85990          """
85991          test interploation of constant rank 4 Data on ReducedFunctionOnContactOne
85992          """
85993          w_ref = ReducedFunctionOnContactOne(self.domain)
85994          w_arg = FunctionOnContactOne(self.domain)
85995          val = numpy.array([[[[0.25191897836414423, 0.42126915999112624, 0.7154530949286638, 0.9952365016642971], [0.14662642318396835, 0.7041962973650627, 0.78731215708391, 0.6924357889858904], [0.22827464902688777, 0.7586553848074509, 0.032078529068980566, 0.3212866838599123]], [[0.8731211780918547, 0.6196786661571002, 0.1727227903088394, 0.6346700793467431], [0.015548189946719582, 0.368431899850422, 0.0976598151032797, 0.8252867801788962], [0.9103820506794112, 0.3008037192898215, 0.30540005256297176, 0.27780553926348106]]], [[[0.4757913279940317, 0.2987358078874637, 0.22024292330759987, 0.6229773193005934], [0.922087290469399, 0.892782366331258, 0.5013328004922624, 0.10353773684686463], [0.4895535641548977, 0.8859070541418946, 0.3441366078907462, 0.43419961139201135]], [[0.3088896761180112, 0.5396803247776865, 0.5177493168768168, 0.2875982176137747], [0.8998467954699237, 0.30598290872935097, 0.7523320401608645, 0.6906490971864888], [0.032724534976539266, 0.6958518818724602, 0.1189430874786982, 0.05054464101685496]]], [[[0.2601400928708387, 0.6672691969164184, 0.4520504631150756, 0.5050320420635327], [0.08433613825917274, 0.048789921774640144, 0.12160750905727158, 0.8856044469408108], [0.38082038045179945, 0.4684120562278291, 0.6266534901363282, 0.010003341349897221]], [[0.5532664995018765, 0.7699851130858237, 0.4078565149425506, 0.4962712401556637], [0.1300875433267774, 0.8378778498446537, 0.4411427823165137, 0.3336098908203802], [0.800484509122118, 0.9218586595145473, 0.7032447055420981, 0.355658645314631]]]] ,numpy.float_)
85996          arg = Data(val,w_arg)
85997          res=interpolate(arg,where=w_ref)
85998          self.assertTrue(isinstance(res,Data),"wrong type of result.")
85999          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86000          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
86001          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86002       def test_interpolate_onFunctionOnContactZero_fromConstant_onSolution_rank0(self):
86003          """
86004          test interploation of constant rank 0 Data on FunctionOnContactZero
86005          """
86006          w_ref = FunctionOnContactZero(self.domain)
86007          w_arg = Solution(self.domain)
86008          val = 4.416713e-01
86009          arg = Data(val,(),w_arg)
86010          res=interpolate(arg,where=w_ref)
86011          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86012          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86013          self.assertEqual(res.getShape(),(),"wrong shape of result.")
86014          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86015       def test_interpolate_onFunctionOnContactZero_fromConstant_onSolution_rank1(self):
86016          """
86017          test interploation of constant rank 1 Data on FunctionOnContactZero
86018          """
86019          w_ref = FunctionOnContactZero(self.domain)
86020          w_arg = Solution(self.domain)
86021          val = numpy.array([0.2397685947326934, 0.7097890472485217, 0.9189098860849187] ,numpy.float_)
86022          arg = Data(val,w_arg)
86023          res=interpolate(arg,where=w_ref)
86024          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86025          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86026          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
86027          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86028       def test_interpolate_onFunctionOnContactZero_fromConstant_onSolution_rank2(self):
86029          """
86030          test interploation of constant rank 2 Data on FunctionOnContactZero
86031          """
86032          w_ref = FunctionOnContactZero(self.domain)
86033          w_arg = Solution(self.domain)
86034          val = numpy.array([[0.17602046944924, 0.7956413543116365], [0.15543862150310883, 0.2482828822749814], [0.1538718613145098, 0.6530094362725264], [0.1514329050794636, 0.5257034960240661]] ,numpy.float_)
86035          arg = Data(val,w_arg)
86036          res=interpolate(arg,where=w_ref)
86037          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86038          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86039          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
86040          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86041       def test_interpolate_onFunctionOnContactZero_fromConstant_onSolution_rank3(self):
86042          """
86043          test interploation of constant rank 3 Data on FunctionOnContactZero
86044          """
86045          w_ref = FunctionOnContactZero(self.domain)
86046          w_arg = Solution(self.domain)
86047          val = numpy.array([[[0.4902557912844012, 0.440304985891957, 0.9463253262661137, 0.5715680435601652], [0.8140505952959916, 0.47358128328833893, 0.996854593429773, 0.13513348645448808]], [[0.22438828201655725, 0.6934202420714549, 0.5177454252945897, 0.1372828042658516], [0.6665024488555925, 0.8896168906819952, 0.4059514060217976, 0.48127708062411934]]] ,numpy.float_)
86048          arg = Data(val,w_arg)
86049          res=interpolate(arg,where=w_ref)
86050          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86051          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86052          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
86053          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86054       def test_interpolate_onFunctionOnContactZero_fromConstant_onSolution_rank4(self):
86055          """
86056          test interploation of constant rank 4 Data on FunctionOnContactZero
86057          """
86058          w_ref = FunctionOnContactZero(self.domain)
86059          w_arg = Solution(self.domain)
86060          val = numpy.array([[[[0.5198503742148101, 0.23333916232844198, 0.45481213788554153, 0.6641616556715114], [0.5025725242121142, 0.7338599485235121, 0.8027874427683204, 0.04573894917401766], [0.06675459781397808, 0.04327693142551525, 0.9214794390300253, 0.673903707702856]], [[0.0021792127542202833, 0.36032368666476733, 0.8700110328075396, 0.3093369106906919], [0.22764719174857673, 0.10616278045101124, 0.1325575760664841, 0.46319086008170507], [0.9828152112752936, 0.6431208639782472, 0.7605833063626741, 0.6791836108384837]]], [[[0.9706310538066029, 0.6736311634646226, 0.20946760175041101, 0.2186355830532991], [0.030648945491146273, 0.12217926635715637, 0.7531427688395137, 0.07597018308112102], [0.9798259336546012, 0.4127985068978618, 0.17669965605585392, 0.22457811769077984]], [[0.6626413306808323, 0.7112410623943974, 0.2822240910976339, 0.2978993862038072], [0.3575751872844851, 0.1718195504274722, 0.09946553575943917, 0.31405656569563933], [0.15235623461362402, 0.6764695857236684, 0.4415189794350217, 0.4692313872286529]]], [[[0.5571194011015072, 0.13980736379490633, 0.828462961394972, 0.6520829063879348], [0.18968066803128192, 0.30163313060691166, 0.3329757076456661, 0.983952227909519], [0.3135321066461725, 0.3773481332917946, 0.9420848004040188, 0.08147895844855246]], [[0.481955104520406, 0.5055841393922007, 0.3444043816788931, 0.027329674792177294], [0.7097385615922654, 0.6189655499331437, 0.1308682118965171, 0.515859974532883], [0.05355114050128118, 0.18673031877411306, 0.19931819211666413, 0.9013240937315466]]]] ,numpy.float_)
86061          arg = Data(val,w_arg)
86062          res=interpolate(arg,where=w_ref)
86063          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86064          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86065          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
86066          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86067       def test_interpolate_onFunctionOnContactZero_fromConstant_onReducedSolution_rank0(self):
86068          """
86069          test interploation of constant rank 0 Data on FunctionOnContactZero
86070          """
86071          w_ref = FunctionOnContactZero(self.domain)
86072          w_arg = ReducedSolution(self.domain)
86073          val = 7.510911e-01
86074          arg = Data(val,(),w_arg)
86075          res=interpolate(arg,where=w_ref)
86076          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86077          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86078          self.assertEqual(res.getShape(),(),"wrong shape of result.")
86079          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86080       def test_interpolate_onFunctionOnContactZero_fromConstant_onReducedSolution_rank1(self):
86081          """
86082          test interploation of constant rank 1 Data on FunctionOnContactZero
86083          """
86084          w_ref = FunctionOnContactZero(self.domain)
86085          w_arg = ReducedSolution(self.domain)
86086          val = numpy.array([0.630645745721905, 0.8939684421289026, 0.9601162395275649] ,numpy.float_)
86087          arg = Data(val,w_arg)
86088          res=interpolate(arg,where=w_ref)
86089          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86090          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86091          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
86092          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86093       def test_interpolate_onFunctionOnContactZero_fromConstant_onReducedSolution_rank2(self):
86094          """
86095          test interploation of constant rank 2 Data on FunctionOnContactZero
86096          """
86097          w_ref = FunctionOnContactZero(self.domain)
86098          w_arg = ReducedSolution(self.domain)
86099          val = numpy.array([[0.02126952766669543, 0.4458741782828476], [0.3809314199301166, 0.11701990827994091], [0.873777780491416, 0.8230600714159015], [0.5028610747815478, 0.09887432015946263]] ,numpy.float_)
86100          arg = Data(val,w_arg)
86101          res=interpolate(arg,where=w_ref)
86102          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86103          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86104          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
86105          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86106       def test_interpolate_onFunctionOnContactZero_fromConstant_onReducedSolution_rank3(self):
86107          """
86108          test interploation of constant rank 3 Data on FunctionOnContactZero
86109          """
86110          w_ref = FunctionOnContactZero(self.domain)
86111          w_arg = ReducedSolution(self.domain)
86112          val = numpy.array([[[0.8966507131291467, 0.286358857446412, 0.4800362539759593, 0.6495513851425094], [0.5178427919521975, 0.01531019627616903, 0.5689211306550106, 0.36217620346944623]], [[0.8502537388147945, 0.6857268648635135, 0.27215688726081644, 0.7716588833363628], [0.4473005431632585, 0.5635508146243543, 0.18066137241072755, 0.8482767005377161]]] ,numpy.float_)
86113          arg = Data(val,w_arg)
86114          res=interpolate(arg,where=w_ref)
86115          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86116          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86117          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
86118          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86119       def test_interpolate_onFunctionOnContactZero_fromConstant_onReducedSolution_rank4(self):
86120          """
86121          test interploation of constant rank 4 Data on FunctionOnContactZero
86122          """
86123          w_ref = FunctionOnContactZero(self.domain)
86124          w_arg = ReducedSolution(self.domain)
86125          val = numpy.array([[[[0.2750355293806127, 0.5390467395895852, 0.8439927541767266, 0.5090111628883961], [0.27350493869815096, 0.37273228754252774, 0.1662453090753061, 0.13560569579061832], [0.7354386331965185, 0.051108003331235885, 0.06031589755776645, 0.30154602205947545]], [[0.6920775172275642, 0.8501136792107697, 0.21023395859900362, 0.956730824374313], [0.1859320728226913, 0.07787267769488615, 0.5130302327416403, 0.3400327980674329], [0.042897263695016785, 0.3818048048698155, 0.6392209318676889, 0.12165560206540982]]], [[[0.18344558842091896, 0.7619916973943744, 0.4909055613828005, 0.07804749944815503], [0.07929391923541218, 0.716420484177726, 0.2581418542426863, 0.07807784079948155], [0.9950388762434933, 0.4004671220915821, 0.6829278998786378, 0.38203800041773084]], [[0.5575655055312282, 0.12066084517531162, 0.8239805798960135, 0.2330351600266607], [0.2764800102169849, 0.5290179635749851, 0.3774607516731834, 0.22767364978997406], [0.6006583474371304, 0.06202361570967674, 0.6882843425453093, 0.18431133952073864]]], [[[0.5655563514285874, 0.78224967695824, 0.5842534247879523, 0.3436621666271471], [0.27003028864710354, 0.13333711261716463, 0.8666408847862285, 0.9839257744154463], [0.4637395857695982, 0.07962639384265635, 0.18918116101042848, 0.7291141678302442]], [[0.35801260833911974, 0.07696594370037868, 0.8058358324912938, 0.9954433534714624], [0.6075857423675662, 0.2182879784226538, 0.8181979449596574, 0.4222063110465062], [0.47275862738828045, 0.060720581084092395, 0.004203445385625226, 0.2439379081924069]]]] ,numpy.float_)
86126          arg = Data(val,w_arg)
86127          res=interpolate(arg,where=w_ref)
86128          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86129          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86130          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
86131          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86132       def test_interpolate_onFunctionOnContactZero_fromConstant_onContinuousFunction_rank0(self):
86133          """
86134          test interploation of constant rank 0 Data on FunctionOnContactZero
86135          """
86136          w_ref = FunctionOnContactZero(self.domain)
86137          w_arg = ContinuousFunction(self.domain)
86138          val = 2.992490e-01
86139          arg = Data(val,(),w_arg)
86140          res=interpolate(arg,where=w_ref)
86141          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86142          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86143          self.assertEqual(res.getShape(),(),"wrong shape of result.")
86144          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86145       def test_interpolate_onFunctionOnContactZero_fromConstant_onContinuousFunction_rank1(self):
86146          """
86147          test interploation of constant rank 1 Data on FunctionOnContactZero
86148          """
86149          w_ref = FunctionOnContactZero(self.domain)
86150          w_arg = ContinuousFunction(self.domain)
86151          val = numpy.array([0.9084081458069398, 0.9610955917455746, 0.8974375039525531] ,numpy.float_)
86152          arg = Data(val,w_arg)
86153          res=interpolate(arg,where=w_ref)
86154          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86155          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86156          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
86157          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86158       def test_interpolate_onFunctionOnContactZero_fromConstant_onContinuousFunction_rank2(self):
86159          """
86160          test interploation of constant rank 2 Data on FunctionOnContactZero
86161          """
86162          w_ref = FunctionOnContactZero(self.domain)
86163          w_arg = ContinuousFunction(self.domain)
86164          val = numpy.array([[0.36406610333741973, 0.7193115171409343], [0.49520067354065733, 0.4648841623168536], [0.5691510386664795, 0.3835616339040089], [0.2894998741692758, 0.37981618394481365]] ,numpy.float_)
86165          arg = Data(val,w_arg)
86166          res=interpolate(arg,where=w_ref)
86167          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86168          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86169          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
86170          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86171       def test_interpolate_onFunctionOnContactZero_fromConstant_onContinuousFunction_rank3(self):
86172          """
86173          test interploation of constant rank 3 Data on FunctionOnContactZero
86174          """
86175          w_ref = FunctionOnContactZero(self.domain)
86176          w_arg = ContinuousFunction(self.domain)
86177          val = numpy.array([[[0.33657633210799043, 0.8515767774529702, 0.8583862148104472, 0.6285488042554537], [0.11901978484130082, 0.04043558134072045, 0.11153632753267007, 0.008877017782832008]], [[0.8754297146483313, 0.7855330600535763, 0.8609253136976776, 0.09305497491150616], [0.22851466737323767, 0.8538173044233048, 0.3508007751425648, 0.05235128240361597]]] ,numpy.float_)
86178          arg = Data(val,w_arg)
86179          res=interpolate(arg,where=w_ref)
86180          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86181          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86182          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
86183          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86184       def test_interpolate_onFunctionOnContactZero_fromConstant_onContinuousFunction_rank4(self):
86185          """
86186          test interploation of constant rank 4 Data on FunctionOnContactZero
86187          """
86188          w_ref = FunctionOnContactZero(self.domain)
86189          w_arg = ContinuousFunction(self.domain)
86190          val = numpy.array([[[[0.37153387003771776, 0.8493606594813612, 0.054706437487670456, 0.0924185624762155], [0.7226040985185594, 0.3132258446969316, 0.07404727361065322, 0.006450500963350092], [0.3815230607784271, 0.4018203119540481, 0.7616728010837144, 0.5850116319392834]], [[0.8925192223767027, 0.15133391013460795, 0.6984644061929081, 0.09425477063877874], [0.003491070140467567, 0.060347953448054326, 0.47564528258681327, 0.8066401750422154], [0.5600675174531321, 0.24591977989820601, 0.8690581332718511, 0.21111001513338168]]], [[[0.1281761411140654, 0.07227128229669033, 0.13401495978275313, 0.3413758890063746], [0.9174989644207403, 0.745648533903282, 0.7828693889445822, 0.5933107087595659], [0.7497147035078707, 0.45508225240513633, 0.03457097069305781, 0.9104863861267437]], [[0.9793179113174781, 0.6727202614912273, 0.06399081591456579, 0.2222167201613352], [0.7271571253320678, 0.08183536821421089, 0.816260427759079, 0.3457936525026265], [0.4868492856427924, 0.32433352456137887, 0.21167787570248076, 0.0581860749528339]]], [[[0.9831713825535134, 0.07509969410304307, 0.07490358211827342, 0.03282166725581881], [0.12044168486481666, 0.515154457439558, 0.2839219961190307, 0.5630409332887808], [0.06183068822143256, 0.31030913114218295, 0.16646500351640292, 0.5675143797937996]], [[0.4191681625715874, 0.8074590639967545, 0.07825860740935309, 0.15450090906733305], [0.720588407598866, 0.3649309179206196, 0.9216552026450284, 0.4021699442404362], [0.5983140824706527, 0.05297429697060296, 0.5158481932356002, 0.4119755592458536]]]] ,numpy.float_)
86191          arg = Data(val,w_arg)
86192          res=interpolate(arg,where=w_ref)
86193          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86194          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86195          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
86196          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86197       def test_interpolate_onFunctionOnContactZero_fromConstant_onReducedContinuousFunction_rank0(self):
86198          """
86199          test interploation of constant rank 0 Data on FunctionOnContactZero
86200          """
86201          w_ref = FunctionOnContactZero(self.domain)
86202          w_arg = ReducedContinuousFunction(self.domain)
86203          val = 8.252940e-03
86204          arg = Data(val,(),w_arg)
86205          res=interpolate(arg,where=w_ref)
86206          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86207          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86208          self.assertEqual(res.getShape(),(),"wrong shape of result.")
86209          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86210       def test_interpolate_onFunctionOnContactZero_fromConstant_onReducedContinuousFunction_rank1(self):
86211          """
86212          test interploation of constant rank 1 Data on FunctionOnContactZero
86213          """
86214          w_ref = FunctionOnContactZero(self.domain)
86215          w_arg = ReducedContinuousFunction(self.domain)
86216          val = numpy.array([0.3448076505076355, 0.6900313488599504, 0.10567828073717866] ,numpy.float_)
86217          arg = Data(val,w_arg)
86218          res=interpolate(arg,where=w_ref)
86219          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86220          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86221          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
86222          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86223       def test_interpolate_onFunctionOnContactZero_fromConstant_onReducedContinuousFunction_rank2(self):
86224          """
86225          test interploation of constant rank 2 Data on FunctionOnContactZero
86226          """
86227          w_ref = FunctionOnContactZero(self.domain)
86228          w_arg = ReducedContinuousFunction(self.domain)
86229          val = numpy.array([[0.35470766202138115, 0.09986094598261086], [0.25266424864387704, 0.8779949525205841], [0.25042177170139934, 0.9036032068029195], [0.2008528682884816, 0.2378173838456351]] ,numpy.float_)
86230          arg = Data(val,w_arg)
86231          res=interpolate(arg,where=w_ref)
86232          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86233          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86234          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
86235          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86236       def test_interpolate_onFunctionOnContactZero_fromConstant_onReducedContinuousFunction_rank3(self):
86237          """
86238          test interploation of constant rank 3 Data on FunctionOnContactZero
86239          """
86240          w_ref = FunctionOnContactZero(self.domain)
86241          w_arg = ReducedContinuousFunction(self.domain)
86242          val = numpy.array([[[0.3273639347586249, 0.9298261012414404, 0.913701750025211, 0.4736803614698052], [0.7635912130688315, 0.13183737655423222, 0.7760816387793189, 0.4818779091034959]], [[0.7352230033431076, 0.7815834720194401, 0.6304488851014184, 0.8742794921950976], [0.5281738455853388, 0.2752856031288444, 0.377977956892526, 0.013672625494558499]]] ,numpy.float_)
86243          arg = Data(val,w_arg)
86244          res=interpolate(arg,where=w_ref)
86245          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86246          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86247          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
86248          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86249       def test_interpolate_onFunctionOnContactZero_fromConstant_onReducedContinuousFunction_rank4(self):
86250          """
86251          test interploation of constant rank 4 Data on FunctionOnContactZero
86252          """
86253          w_ref = FunctionOnContactZero(self.domain)
86254          w_arg = ReducedContinuousFunction(self.domain)
86255          val = numpy.array([[[[0.9806721863738455, 0.9420397905945826, 0.4759653563480256, 0.6838085617199985], [0.7235282182444596, 0.43366565885057873, 0.8112074102767002, 0.8284908996938819], [0.02974965437016075, 0.697613323352396, 0.5186387902996138, 0.04365161154110808]], [[0.5832773206987517, 0.9810209479115547, 0.6061630212424512, 0.46604203254036913], [0.8135907770650561, 0.8031912402292878, 0.29726297081314557, 0.21332985568864593], [0.42801658535045817, 0.7534302538432589, 0.6211769880606737, 0.9192451559580421]]], [[[0.6844579365139096, 0.20548191610037114, 0.7468354520285635, 0.7630304942291364], [0.5313483043271173, 0.25313222404919977, 0.9073834488147124, 0.0715532276750892], [0.7732593974641134, 0.14943053384767535, 0.7162983381990314, 0.49004571909471895]], [[0.8198603739899627, 0.36728047400449204, 0.5123151807849293, 0.9828245159299462], [0.35736608493209954, 0.9939711062328335, 0.12255412576671498, 0.4431013295983658], [0.47455302203504757, 0.9657076599292064, 0.9215547472021081, 0.5422555904839185]]], [[[0.7192153597996084, 0.9007403952562474, 0.579916428899817, 0.43747395368978603], [0.5733828993717659, 0.7961898331137294, 0.7205227665391735, 0.09394967176864544], [0.43995237266279985, 0.1339366322472404, 0.7840868152248345, 0.8102066218380822]], [[0.06692787457453286, 0.5475617072862115, 0.9191194246666381, 0.6476330805729692], [0.21633461620688066, 0.5717077212234045, 0.3388888775576444, 0.10502341187582986], [0.5909013124923022, 0.8178615500689735, 0.34284763698586973, 0.38611240571854644]]]] ,numpy.float_)
86256          arg = Data(val,w_arg)
86257          res=interpolate(arg,where=w_ref)
86258          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86259          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86260          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
86261          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86262       def test_interpolate_onFunctionOnContactZero_fromConstant_onFunctionOnContactZero_rank0(self):
86263          """
86264          test interploation of constant rank 0 Data on FunctionOnContactZero
86265          """
86266          w_ref = FunctionOnContactZero(self.domain)
86267          w_arg = FunctionOnContactZero(self.domain)
86268          val = 7.327513e-01
86269          arg = Data(val,(),w_arg)
86270          res=interpolate(arg,where=w_ref)
86271          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86272          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86273          self.assertEqual(res.getShape(),(),"wrong shape of result.")
86274          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86275       def test_interpolate_onFunctionOnContactZero_fromConstant_onFunctionOnContactZero_rank1(self):
86276          """
86277          test interploation of constant rank 1 Data on FunctionOnContactZero
86278          """
86279          w_ref = FunctionOnContactZero(self.domain)
86280          w_arg = FunctionOnContactZero(self.domain)
86281          val = numpy.array([0.7231166515226765, 0.5841319152801158, 0.8902160789797313] ,numpy.float_)
86282          arg = Data(val,w_arg)
86283          res=interpolate(arg,where=w_ref)
86284          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86285          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86286          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
86287          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86288       def test_interpolate_onFunctionOnContactZero_fromConstant_onFunctionOnContactZero_rank2(self):
86289          """
86290          test interploation of constant rank 2 Data on FunctionOnContactZero
86291          """
86292          w_ref = FunctionOnContactZero(self.domain)
86293          w_arg = FunctionOnContactZero(self.domain)
86294          val = numpy.array([[0.31666674128214967, 0.8082352527788402], [0.5527436152270833, 0.9022399259157667], [0.09592541580574276, 0.2921831081543108], [0.4304143124615589, 0.10331014717749942]] ,numpy.float_)
86295          arg = Data(val,w_arg)
86296          res=interpolate(arg,where=w_ref)
86297          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86298          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86299          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
86300          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86301       def test_interpolate_onFunctionOnContactZero_fromConstant_onFunctionOnContactZero_rank3(self):
86302          """
86303          test interploation of constant rank 3 Data on FunctionOnContactZero
86304          """
86305          w_ref = FunctionOnContactZero(self.domain)
86306          w_arg = FunctionOnContactZero(self.domain)
86307          val = numpy.array([[[0.15595661516165404, 0.7833734244427264, 0.24540644204391682, 0.1542925747281464], [0.15838583560617558, 0.7395401696574047, 0.7346352689491014, 0.24458004081631357]], [[0.19927127813017875, 0.8777192033205472, 0.8491994511001953, 0.4703062874568794], [0.980759804700044, 0.9682583138081405, 0.3790846035822203, 0.38138319170544466]]] ,numpy.float_)
86308          arg = Data(val,w_arg)
86309          res=interpolate(arg,where=w_ref)
86310          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86311          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86312          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
86313          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86314       def test_interpolate_onFunctionOnContactZero_fromConstant_onFunctionOnContactZero_rank4(self):
86315          """
86316          test interploation of constant rank 4 Data on FunctionOnContactZero
86317          """
86318          w_ref = FunctionOnContactZero(self.domain)
86319          w_arg = FunctionOnContactZero(self.domain)
86320          val = numpy.array([[[[0.20419114009277073, 0.647175983842068, 0.5093547151876396, 0.9216011526617293], [0.42295910976817985, 0.7188670182816705, 0.7741150536748513, 0.45558965220901193], [0.03436003707429747, 0.07563143784432569, 0.48620344230809576, 0.8013645733575203]], [[0.7771578779880213, 0.19603575918509386, 0.5985466948715691, 0.828958278366855], [0.0938459606708103, 0.19187906528756593, 0.01662095587451151, 0.15028937565734368], [0.034012959068946524, 0.35696919619085865, 0.12750367788423345, 0.9458667600166505]]], [[[0.22776111844779323, 0.74809180845036, 0.06489892587426582, 0.8765495727006761], [0.5693912992359508, 0.41255204446644667, 0.7066014359982783, 0.9717171105845629], [0.6876321588836807, 0.201805999400562, 0.5208661607283092, 0.26638579370241744]], [[0.8755482739394753, 0.20448437653898544, 0.4944880065113454, 0.03192709625044665], [0.6751522218320636, 0.6008625798947532, 0.6395416148567048, 0.3754171935071611], [0.33160648108815993, 0.02753911680324972, 0.3281591135689743, 0.8736536966446298]]], [[[0.33033444631590414, 0.9802368565740771, 0.3604057339737867, 0.4530725735113721], [0.20764202465902182, 0.9977143081423786, 0.9781748640481389, 0.28129650096176884], [0.3811869625421732, 0.9110908868512202, 0.8997281186553494, 0.8398212773868227]], [[0.8337359476242638, 0.24012391654438614, 0.30322675360573226, 0.4998867082796524], [0.11277484849791797, 0.7619896431886289, 0.4162911610580866, 0.5064994338014415], [0.8550867003183041, 0.4168470403089801, 0.18660226726284013, 0.37137042986275126]]]] ,numpy.float_)
86321          arg = Data(val,w_arg)
86322          res=interpolate(arg,where=w_ref)
86323          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86324          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86325          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
86326          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86327       def test_interpolate_onFunctionOnContactZero_fromConstant_onFunctionOnContactOne_rank0(self):
86328          """
86329          test interploation of constant rank 0 Data on FunctionOnContactZero
86330          """
86331          w_ref = FunctionOnContactZero(self.domain)
86332          w_arg = FunctionOnContactOne(self.domain)
86333          val = 8.486111e-01
86334          arg = Data(val,(),w_arg)
86335          res=interpolate(arg,where=w_ref)
86336          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86337          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86338          self.assertEqual(res.getShape(),(),"wrong shape of result.")
86339          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86340       def test_interpolate_onFunctionOnContactZero_fromConstant_onFunctionOnContactOne_rank1(self):
86341          """
86342          test interploation of constant rank 1 Data on FunctionOnContactZero
86343          """
86344          w_ref = FunctionOnContactZero(self.domain)
86345          w_arg = FunctionOnContactOne(self.domain)
86346          val = numpy.array([0.19349620530877265, 0.5866471986054227, 0.6787889731753596] ,numpy.float_)
86347          arg = Data(val,w_arg)
86348          res=interpolate(arg,where=w_ref)
86349          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86350          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86351          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
86352          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86353       def test_interpolate_onFunctionOnContactZero_fromConstant_onFunctionOnContactOne_rank2(self):
86354          """
86355          test interploation of constant rank 2 Data on FunctionOnContactZero
86356          """
86357          w_ref = FunctionOnContactZero(self.domain)
86358          w_arg = FunctionOnContactOne(self.domain)
86359          val = numpy.array([[0.2822602679507009, 0.40533825534315016], [0.7258825121048694, 0.5324694570640633], [0.36909609843304925, 0.12198043686742], [0.12075237403480787, 0.5785326226174939]] ,numpy.float_)
86360          arg = Data(val,w_arg)
86361          res=interpolate(arg,where=w_ref)
86362          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86363          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86364          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
86365          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86366       def test_interpolate_onFunctionOnContactZero_fromConstant_onFunctionOnContactOne_rank3(self):
86367          """
86368          test interploation of constant rank 3 Data on FunctionOnContactZero
86369          """
86370          w_ref = FunctionOnContactZero(self.domain)
86371          w_arg = FunctionOnContactOne(self.domain)
86372          val = numpy.array([[[0.5346208611352831, 0.4469842740453335, 0.8051916060864622, 0.48733380565029016], [0.8307328127369256, 0.9393115411216822, 0.4398715323854856, 0.29522037647769916]], [[0.5870016848993143, 0.019098167430426027, 0.6116361915920812, 0.8720224112887579], [0.572976558198275, 0.49941509000507023, 0.5946267689626442, 0.6475179416827223]]] ,numpy.float_)
86373          arg = Data(val,w_arg)
86374          res=interpolate(arg,where=w_ref)
86375          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86376          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86377          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
86378          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86379       def test_interpolate_onFunctionOnContactZero_fromConstant_onFunctionOnContactOne_rank4(self):
86380          """
86381          test interploation of constant rank 4 Data on FunctionOnContactZero
86382          """
86383          w_ref = FunctionOnContactZero(self.domain)
86384          w_arg = FunctionOnContactOne(self.domain)
86385          val = numpy.array([[[[0.9274001658794875, 0.28129554243035704, 0.8781639418523312, 0.2502775019483543], [0.7044955363081367, 0.9041118440883114, 0.3602052270922288, 0.9985565147392614], [0.5972379373665277, 0.06713057365947417, 0.3620165408330318, 0.9772450466979303]], [[0.07320303071616574, 0.9460091082631562, 0.6608561394784608, 0.896991807046738], [0.7057319905818371, 0.8650091980891809, 0.5950323580975542, 0.8086663075937696], [0.5485181344188715, 0.9445866937441508, 0.3153107315109378, 0.36858289115803966]]], [[[0.7786183386104515, 0.3609547326506787, 0.02311328299808979, 0.9530050392474433], [0.1446153236837675, 0.9190223271985497, 0.24760153477578672, 0.2796250506324369], [0.901051983379246, 0.11340072399800483, 0.39826787824937204, 0.8644036183549159]], [[0.0030006812566425456, 0.5197289474173273, 0.12424284697360144, 0.9422373979654418], [0.04495511401683372, 0.03315171261125649, 0.18692678365674031, 0.056481667996537754], [0.9377011841037844, 0.4731040233528967, 0.5373841539527175, 0.25562355372378565]]], [[[0.2537851697115757, 0.14094081127476776, 0.010205458967384562, 0.20765140118592673], [0.02999979580974721, 0.11038237323218791, 0.8244473412279174, 0.5810733992018395], [0.9967498428234133, 0.7796913893645318, 0.4926493661339262, 0.1907508420561247]], [[0.5485212280712575, 0.6002896061014056, 0.47343878848488685, 0.6739775413957486], [0.22382265206362462, 0.5212412074684933, 0.5298640334376036, 0.3071447604012596], [0.42094268186296824, 0.8827363291256063, 0.9730196003317173, 0.5689645278272888]]]] ,numpy.float_)
86386          arg = Data(val,w_arg)
86387          res=interpolate(arg,where=w_ref)
86388          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86389          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86390          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
86391          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86392       def test_interpolate_onFunctionOnContactOne_fromConstant_onSolution_rank0(self):
86393          """
86394          test interploation of constant rank 0 Data on FunctionOnContactOne
86395          """
86396          w_ref = FunctionOnContactOne(self.domain)
86397          w_arg = Solution(self.domain)
86398          val = 5.767294e-01
86399          arg = Data(val,(),w_arg)
86400          res=interpolate(arg,where=w_ref)
86401          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86402          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86403          self.assertEqual(res.getShape(),(),"wrong shape of result.")
86404          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86405       def test_interpolate_onFunctionOnContactOne_fromConstant_onSolution_rank1(self):
86406          """
86407          test interploation of constant rank 1 Data on FunctionOnContactOne
86408          """
86409          w_ref = FunctionOnContactOne(self.domain)
86410          w_arg = Solution(self.domain)
86411          val = numpy.array([0.9393272777113492, 0.3566768496456404, 0.5950175292092031] ,numpy.float_)
86412          arg = Data(val,w_arg)
86413          res=interpolate(arg,where=w_ref)
86414          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86415          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86416          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
86417          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86418       def test_interpolate_onFunctionOnContactOne_fromConstant_onSolution_rank2(self):
86419          """
86420          test interploation of constant rank 2 Data on FunctionOnContactOne
86421          """
86422          w_ref = FunctionOnContactOne(self.domain)
86423          w_arg = Solution(self.domain)
86424          val = numpy.array([[0.24432369184270464, 0.51048589333877], [0.651880378266647, 0.7871665354232306], [0.8156590150712001, 0.607738119865395], [0.7271726943916907, 0.1811763770522743]] ,numpy.float_)
86425          arg = Data(val,w_arg)
86426          res=interpolate(arg,where=w_ref)
86427          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86428          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86429          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
86430          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86431       def test_interpolate_onFunctionOnContactOne_fromConstant_onSolution_rank3(self):
86432          """
86433          test interploation of constant rank 3 Data on FunctionOnContactOne
86434          """
86435          w_ref = FunctionOnContactOne(self.domain)
86436          w_arg = Solution(self.domain)
86437          val = numpy.array([[[0.4893404027379529, 0.7143945993639663, 0.2800095632387746, 0.03077209934310221], [0.09741763000806669, 0.9523828574035264, 0.6150161165584151, 0.07683227286346894]], [[0.41437984289378427, 0.8512176451950799, 0.19676008983148308, 0.6302950649094535], [0.2566098357459874, 0.8458667868726177, 0.726098072274147, 0.22583237649855714]]] ,numpy.float_)
86438          arg = Data(val,w_arg)
86439          res=interpolate(arg,where=w_ref)
86440          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86441          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86442          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
86443          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86444       def test_interpolate_onFunctionOnContactOne_fromConstant_onSolution_rank4(self):
86445          """
86446          test interploation of constant rank 4 Data on FunctionOnContactOne
86447          """
86448          w_ref = FunctionOnContactOne(self.domain)
86449          w_arg = Solution(self.domain)
86450          val = numpy.array([[[[0.33039432387156287, 0.8483347767807963, 0.3038197358056276, 0.3173098177329524], [0.2617638288301254, 0.2379318906112151, 0.9277003165528401, 0.26256000875539154], [0.49140753839399287, 0.7944876328294765, 0.5673496116390729, 0.7484953495934313]], [[0.15357034592966234, 0.22551372099204892, 0.44522517076017576, 0.7589320701726646], [0.020031921785506612, 0.8980125272861668, 0.5927958056182403, 0.6626111290187529], [0.16366391987541307, 0.7866885462330552, 0.2519000928757915, 0.6237889465762602]]], [[[0.3265396885581284, 0.40298064992746185, 0.9851664096048879, 0.7456683000131761], [0.4044007732457938, 0.9318879431120379, 0.49611085891547846, 0.9086679158503379], [0.7819868747485897, 0.37812640508932105, 0.08203140235780115, 0.4091759221026524]], [[0.2638073355435474, 0.7097331633234422, 0.11199217920819804, 0.8332891900252846], [0.7289120583934607, 0.8044279698358008, 0.6202194678103693, 0.9047066999710591], [0.7347242082064213, 0.6815120792749805, 0.5714184226956788, 0.9289316135807777]]], [[[0.5843985120672339, 0.3585269600730254, 0.849389223566183, 0.5846480341029401], [0.9290824575336621, 0.27583542447387044, 0.028879475459195447, 0.38621936577061455], [0.2451827909850518, 0.5787995107442441, 0.2579913053469185, 0.24571157118058595]], [[0.745288740109279, 0.8716589775031495, 0.9306469293450405, 0.9614185299822352], [0.3867084350612561, 0.053525113091472676, 0.15825875323679062, 0.5391251968145623], [0.3222790115730473, 0.9376764774926398, 0.2243389246548435, 0.6395499141302641]]]] ,numpy.float_)
86451          arg = Data(val,w_arg)
86452          res=interpolate(arg,where=w_ref)
86453          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86454          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86455          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
86456          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86457       def test_interpolate_onFunctionOnContactOne_fromConstant_onReducedSolution_rank0(self):
86458          """
86459          test interploation of constant rank 0 Data on FunctionOnContactOne
86460          """
86461          w_ref = FunctionOnContactOne(self.domain)
86462          w_arg = ReducedSolution(self.domain)
86463          val = 1.909980e-02
86464          arg = Data(val,(),w_arg)
86465          res=interpolate(arg,where=w_ref)
86466          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86467          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86468          self.assertEqual(res.getShape(),(),"wrong shape of result.")
86469          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86470       def test_interpolate_onFunctionOnContactOne_fromConstant_onReducedSolution_rank1(self):
86471          """
86472          test interploation of constant rank 1 Data on FunctionOnContactOne
86473          """
86474          w_ref = FunctionOnContactOne(self.domain)
86475          w_arg = ReducedSolution(self.domain)
86476          val = numpy.array([0.9310097157024845, 0.9598516961599882, 0.5426786184009288] ,numpy.float_)
86477          arg = Data(val,w_arg)
86478          res=interpolate(arg,where=w_ref)
86479          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86480          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86481          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
86482          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86483       def test_interpolate_onFunctionOnContactOne_fromConstant_onReducedSolution_rank2(self):
86484          """
86485          test interploation of constant rank 2 Data on FunctionOnContactOne
86486          """
86487          w_ref = FunctionOnContactOne(self.domain)
86488          w_arg = ReducedSolution(self.domain)
86489          val = numpy.array([[0.05119923247920832, 0.41079030463174626], [0.7601386446015862, 0.850554845330653], [0.4423350538349472, 0.1180775929815242], [0.9840637068902307, 0.5097944715854054]] ,numpy.float_)
86490          arg = Data(val,w_arg)
86491          res=interpolate(arg,where=w_ref)
86492          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86493          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86494          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
86495          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86496       def test_interpolate_onFunctionOnContactOne_fromConstant_onReducedSolution_rank3(self):
86497          """
86498          test interploation of constant rank 3 Data on FunctionOnContactOne
86499          """
86500          w_ref = FunctionOnContactOne(self.domain)
86501          w_arg = ReducedSolution(self.domain)
86502          val = numpy.array([[[0.6929617892145945, 0.8564860009098837, 0.09862451701848529, 0.9927354003452259], [0.618567040058047, 0.8109588623837427, 0.43985230793568897, 0.696936365283216]], [[0.7713616009191991, 0.7370842239587223, 0.5144762584826544, 0.6902963812144104], [0.08556994290820097, 0.290021600059007, 0.0675561465235971, 0.5666089364555084]]] ,numpy.float_)
86503          arg = Data(val,w_arg)
86504          res=interpolate(arg,where=w_ref)
86505          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86506          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86507          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
86508          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86509       def test_interpolate_onFunctionOnContactOne_fromConstant_onReducedSolution_rank4(self):
86510          """
86511          test interploation of constant rank 4 Data on FunctionOnContactOne
86512          """
86513          w_ref = FunctionOnContactOne(self.domain)
86514          w_arg = ReducedSolution(self.domain)
86515          val = numpy.array([[[[0.8040132408324383, 0.05740157341271068, 0.9954811313394446, 0.9307313044733667], [0.8832816764924746, 0.9088044114136531, 0.09793082858191304, 0.7900115380295009], [0.44859461087747887, 0.7701805309926891, 0.8976019059724086, 0.6149980378552519]], [[0.9040711526397776, 0.7345393514222155, 0.36130436244331954, 0.0750344731625231], [0.10125172271598892, 0.23032718083162607, 0.32180275306924067, 0.2731072430360305], [0.5309712933425926, 0.5194240836074977, 0.2094979496910092, 0.06582580878343891]]], [[[0.15170388765293186, 0.1831511098441868, 0.1918488201791595, 0.918359165512001], [0.250085591384253, 0.4744329151161065, 0.36773681691550497, 0.17016247242238114], [0.7036352886702043, 0.8125491445623759, 0.6720672838705962, 0.0465285745172509]], [[0.09433260987485459, 0.55826558565799, 0.996072681664486, 0.4443346482960586], [0.3951568444418436, 0.138621122057483, 0.7198860321672503, 0.8962949629973527], [0.2681882998995653, 0.05745511213300669, 0.4605882554882842, 0.8685845444503997]]], [[[0.6421953408785401, 0.1757052625120029, 0.21783918421892112, 0.4200436710487724], [0.08834583002749208, 0.19910931327412618, 0.4102105366367709, 0.23533298054459706], [0.5375102589162664, 0.9755080674596786, 0.608682365886696, 0.15439981768265232]], [[0.7088614099110924, 0.29990237337124237, 0.0331339120812264, 0.7154129057225462], [0.7536666092699825, 0.43789075473153205, 0.32489584680417394, 0.03214215964398259], [0.12473044124285826, 0.041151436003503905, 0.9143708537634556, 0.05046875283984975]]]] ,numpy.float_)
86516          arg = Data(val,w_arg)
86517          res=interpolate(arg,where=w_ref)
86518          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86519          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86520          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
86521          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86522       def test_interpolate_onFunctionOnContactOne_fromConstant_onContinuousFunction_rank0(self):
86523          """
86524          test interploation of constant rank 0 Data on FunctionOnContactOne
86525          """
86526          w_ref = FunctionOnContactOne(self.domain)
86527          w_arg = ContinuousFunction(self.domain)
86528          val = 4.772256e-01
86529          arg = Data(val,(),w_arg)
86530          res=interpolate(arg,where=w_ref)
86531          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86532          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86533          self.assertEqual(res.getShape(),(),"wrong shape of result.")
86534          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86535       def test_interpolate_onFunctionOnContactOne_fromConstant_onContinuousFunction_rank1(self):
86536          """
86537          test interploation of constant rank 1 Data on FunctionOnContactOne
86538          """
86539          w_ref = FunctionOnContactOne(self.domain)
86540          w_arg = ContinuousFunction(self.domain)
86541          val = numpy.array([0.13970398691552355, 0.9685019005154762, 0.5091845224613416] ,numpy.float_)
86542          arg = Data(val,w_arg)
86543          res=interpolate(arg,where=w_ref)
86544          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86545          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86546          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
86547          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86548       def test_interpolate_onFunctionOnContactOne_fromConstant_onContinuousFunction_rank2(self):
86549          """
86550          test interploation of constant rank 2 Data on FunctionOnContactOne
86551          """
86552          w_ref = FunctionOnContactOne(self.domain)
86553          w_arg = ContinuousFunction(self.domain)
86554          val = numpy.array([[0.7871247247714709, 0.4695168272735891], [0.08315880520569163, 0.26457851850854774], [0.8627336131338595, 0.39168832860705083], [0.84345293538415, 0.044640616676462574]] ,numpy.float_)
86555          arg = Data(val,w_arg)
86556          res=interpolate(arg,where=w_ref)
86557          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86558          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86559          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
86560          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86561       def test_interpolate_onFunctionOnContactOne_fromConstant_onContinuousFunction_rank3(self):
86562          """
86563          test interploation of constant rank 3 Data on FunctionOnContactOne
86564          """
86565          w_ref = FunctionOnContactOne(self.domain)
86566          w_arg = ContinuousFunction(self.domain)
86567          val = numpy.array([[[0.482642338632141, 0.8133489743365346, 0.7090061264352878, 0.674660169309214], [0.7792521170475486, 0.9375790250660871, 0.5621369310673493, 0.14196279393188171]], [[0.84621492908988, 0.4315664433371823, 0.7105047101494437, 0.9630127116493553], [0.0017345619067646867, 0.14408799614484125, 0.8672034081224578, 0.40599645665431994]]] ,numpy.float_)
86568          arg = Data(val,w_arg)
86569          res=interpolate(arg,where=w_ref)
86570          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86571          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86572          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
86573          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86574       def test_interpolate_onFunctionOnContactOne_fromConstant_onContinuousFunction_rank4(self):
86575          """
86576          test interploation of constant rank 4 Data on FunctionOnContactOne
86577          """
86578          w_ref = FunctionOnContactOne(self.domain)
86579          w_arg = ContinuousFunction(self.domain)
86580          val = numpy.array([[[[0.5025528596467772, 0.6639044803784455, 0.7321936771945932, 0.34396887853487434], [0.3662036100865744, 0.5936347591405934, 0.014391334956976864, 0.1760581286699141], [0.35159192836421216, 0.6131387874422899, 0.8423297697861831, 0.6837804146854264]], [[0.6634900483232942, 0.5239579363473771, 0.4395513950457304, 0.8118070231181496], [0.45523155926102055, 0.7812539148111305, 0.34628795056330886, 0.4809875858330689], [0.6439429777579342, 0.6442238897350978, 0.7881666686221916, 0.8828193937940547]]], [[[0.6412203008644388, 0.6741491134777143, 0.3563794759848351, 0.08352673628003027], [0.6210802083734595, 0.10126987104907625, 0.571281771572459, 0.9818461369488507], [0.15981768383543915, 0.515869829097547, 0.3177613527023123, 0.2270022094614812]], [[0.5225431656130042, 0.948241003786963, 0.8906849122716235, 0.7971527713971847], [0.43011343017143766, 0.8595959184508085, 0.4542020402828335, 0.5253599956035548], [0.12182693232141639, 0.8323040539160632, 0.8244243763405522, 0.10774558353482466]]], [[[0.5531251667837781, 0.6896056884916075, 0.4074899302049373, 0.07062460757672595], [0.5003130136895001, 0.7714971613073536, 0.7820503331058146, 0.474015037770826], [0.6983050632376289, 0.4512337129830044, 0.8416082320993941, 0.31337018427982755]], [[0.15284708758251342, 0.13715548456750493, 0.7545244238170862, 0.03940687094955919], [0.03550432950140048, 0.43858877707216637, 0.015608392276873162, 0.21322764326121024], [0.8286592986359806, 0.02604881256602587, 0.7560447750002263, 0.5518618067515372]]]] ,numpy.float_)
86581          arg = Data(val,w_arg)
86582          res=interpolate(arg,where=w_ref)
86583          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86584          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86585          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
86586          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86587       def test_interpolate_onFunctionOnContactOne_fromConstant_onReducedContinuousFunction_rank0(self):
86588          """
86589          test interploation of constant rank 0 Data on FunctionOnContactOne
86590          """
86591          w_ref = FunctionOnContactOne(self.domain)
86592          w_arg = ReducedContinuousFunction(self.domain)
86593          val = 4.366381e-01
86594          arg = Data(val,(),w_arg)
86595          res=interpolate(arg,where=w_ref)
86596          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86597          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86598          self.assertEqual(res.getShape(),(),"wrong shape of result.")
86599          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86600       def test_interpolate_onFunctionOnContactOne_fromConstant_onReducedContinuousFunction_rank1(self):
86601          """
86602          test interploation of constant rank 1 Data on FunctionOnContactOne
86603          """
86604          w_ref = FunctionOnContactOne(self.domain)
86605          w_arg = ReducedContinuousFunction(self.domain)
86606          val = numpy.array([0.8729896511743298, 0.8592284116201467, 0.7249011457001252] ,numpy.float_)
86607          arg = Data(val,w_arg)
86608          res=interpolate(arg,where=w_ref)
86609          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86610          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86611          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
86612          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86613       def test_interpolate_onFunctionOnContactOne_fromConstant_onReducedContinuousFunction_rank2(self):
86614          """
86615          test interploation of constant rank 2 Data on FunctionOnContactOne
86616          """
86617          w_ref = FunctionOnContactOne(self.domain)
86618          w_arg = ReducedContinuousFunction(self.domain)
86619          val = numpy.array([[0.9592621284831397, 0.43537457044602057], [0.22424733361843718, 0.3967925848358177], [0.8816116559042844, 0.6277335225763199], [0.609653528118983, 0.5582539018213913]] ,numpy.float_)
86620          arg = Data(val,w_arg)
86621          res=interpolate(arg,where=w_ref)
86622          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86623          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86624          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
86625          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86626       def test_interpolate_onFunctionOnContactOne_fromConstant_onReducedContinuousFunction_rank3(self):
86627          """
86628          test interploation of constant rank 3 Data on FunctionOnContactOne
86629          """
86630          w_ref = FunctionOnContactOne(self.domain)
86631          w_arg = ReducedContinuousFunction(self.domain)
86632          val = numpy.array([[[0.8408978798560507, 0.9211923180120242, 0.23506769537534655, 0.14874650599058048], [0.6836138689798581, 0.249682325647547, 0.27166576825803423, 0.08586679061342994]], [[0.5615086339973592, 0.8632454549187649, 0.815910076982812, 0.33757568528084614], [0.1341937252940094, 0.039849570412994306, 0.603971777156599, 0.5051028816540584]]] ,numpy.float_)
86633          arg = Data(val,w_arg)
86634          res=interpolate(arg,where=w_ref)
86635          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86636          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86637          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
86638          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86639       def test_interpolate_onFunctionOnContactOne_fromConstant_onReducedContinuousFunction_rank4(self):
86640          """
86641          test interploation of constant rank 4 Data on FunctionOnContactOne
86642          """
86643          w_ref = FunctionOnContactOne(self.domain)
86644          w_arg = ReducedContinuousFunction(self.domain)
86645          val = numpy.array([[[[0.39042920883550436, 0.09654008742627618, 0.23459468057374977, 0.4997760056783489], [0.9803093359121334, 0.25420567781552883, 0.1384271894889244, 0.652054174046505], [0.6420115372187916, 0.4680093623067527, 0.5545188168878056, 0.8648494463441425]], [[0.2128663216940293, 0.07161356306800726, 0.4159331514787875, 0.42787781855117224], [0.8955262758183068, 0.9575458214197974, 0.4640998721416092, 0.7518401550693129], [0.2724439565287011, 0.24540644244699927, 0.5825295453488123, 0.493757576415915]]], [[[0.2912381581584985, 0.22265719076874357, 0.045927255048914706, 0.502348793920519], [0.14271563481258098, 0.5497283215674386, 0.5011592561560229, 0.3846001208453744], [0.41602958815663127, 0.642881597452492, 0.6389435318509104, 0.7841619838979582]], [[0.822288808976087, 0.9116382463298777, 0.2097320377905011, 0.7615548009091255], [0.5556861573959306, 0.19196072042728163, 0.17980432324983586, 0.636290474090794], [0.1150202543227441, 0.31489520423947726, 0.009489938552266208, 0.3706298964935535]]], [[[0.22628832098316465, 0.06939177618540027, 0.3969239286087368, 0.6363514673381082], [0.9514645526648707, 0.5461826847258049, 0.8724483901590938, 0.15251094070894067], [0.3532567056040524, 0.9447858094976036, 0.5272639786528185, 0.8567212545183848]], [[0.979529498684061, 0.2396888342803456, 0.6268859620853611, 0.8435251665352165], [0.08638429623459332, 0.39944184404828165, 0.7730346446831876, 0.6139768824821263], [0.6467634930821072, 0.7952116992062654, 0.3068758449420531, 0.599335205309747]]]] ,numpy.float_)
86646          arg = Data(val,w_arg)
86647          res=interpolate(arg,where=w_ref)
86648          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86649          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86650          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
86651          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86652       def test_interpolate_onFunctionOnContactOne_fromConstant_onFunctionOnContactZero_rank0(self):
86653          """
86654          test interploation of constant rank 0 Data on FunctionOnContactOne
86655          """
86656          w_ref = FunctionOnContactOne(self.domain)
86657          w_arg = FunctionOnContactZero(self.domain)
86658          val = 5.001400e-01
86659          arg = Data(val,(),w_arg)
86660          res=interpolate(arg,where=w_ref)
86661          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86662          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86663          self.assertEqual(res.getShape(),(),"wrong shape of result.")
86664          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86665       def test_interpolate_onFunctionOnContactOne_fromConstant_onFunctionOnContactZero_rank1(self):
86666          """
86667          test interploation of constant rank 1 Data on FunctionOnContactOne
86668          """
86669          w_ref = FunctionOnContactOne(self.domain)
86670          w_arg = FunctionOnContactZero(self.domain)
86671          val = numpy.array([0.3446244000495903, 0.593446268134426, 0.49417928509040543] ,numpy.float_)
86672          arg = Data(val,w_arg)
86673          res=interpolate(arg,where=w_ref)
86674          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86675          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86676          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
86677          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86678       def test_interpolate_onFunctionOnContactOne_fromConstant_onFunctionOnContactZero_rank2(self):
86679          """
86680          test interploation of constant rank 2 Data on FunctionOnContactOne
86681          """
86682          w_ref = FunctionOnContactOne(self.domain)
86683          w_arg = FunctionOnContactZero(self.domain)
86684          val = numpy.array([[0.7396858665244294, 0.2591321450931059], [0.9138555289206731, 0.5655255068410112], [0.42702057599396614, 0.5538374647017625], [0.30882993796761027, 0.25520699740792707]] ,numpy.float_)
86685          arg = Data(val,w_arg)
86686          res=interpolate(arg,where=w_ref)
86687          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86688          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86689          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
86690          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86691       def test_interpolate_onFunctionOnContactOne_fromConstant_onFunctionOnContactZero_rank3(self):
86692          """
86693          test interploation of constant rank 3 Data on FunctionOnContactOne
86694          """
86695          w_ref = FunctionOnContactOne(self.domain)
86696          w_arg = FunctionOnContactZero(self.domain)
86697          val = numpy.array([[[0.7814574177959093, 0.2885240146553637, 0.07602748917796198, 0.9434537117594162], [0.11453942642341597, 0.6536688083758768, 0.6652350210110864, 0.7007107129601465]], [[0.5159704693548254, 0.08926010595869083, 0.2951171897121806, 0.6056882959408596], [0.977098129471714, 0.3353343460652275, 0.07160809848615957, 0.2081406400615552]]] ,numpy.float_)
86698          arg = Data(val,w_arg)
86699          res=interpolate(arg,where=w_ref)
86700          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86701          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86702          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
86703          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86704       def test_interpolate_onFunctionOnContactOne_fromConstant_onFunctionOnContactZero_rank4(self):
86705          """
86706          test interploation of constant rank 4 Data on FunctionOnContactOne
86707          """
86708          w_ref = FunctionOnContactOne(self.domain)
86709          w_arg = FunctionOnContactZero(self.domain)
86710          val = numpy.array([[[[0.5744208457569366, 0.6276911535940791, 0.4890217568852586, 0.4453990558743598], [0.7413339898808041, 0.3080648676735249, 0.2292644941988884, 0.5558197054430838], [0.27257577986078196, 0.709889311378699, 0.6676133429451673, 0.059791577291348874]], [[0.3321024058463743, 0.5548229915715125, 0.9071852420920024, 0.5798147595802225], [0.06682655216594979, 0.768613476658211, 0.8713989894148532, 0.3730797680034109], [0.3211194675035839, 0.23320985956220253, 0.4834356403659402, 0.4634951292311712]]], [[[0.6196225298971869, 0.7470473319754436, 0.45984942093693193, 0.11062821685289281], [0.7537048674141694, 0.01801585170950748, 0.9888570901074166, 0.7355681564250827], [0.3076423493263659, 0.617722273682797, 0.11707057330441095, 0.7523131779840234]], [[0.23172405807175178, 0.1577333122816379, 0.2485127649785972, 0.720628815651124], [0.936358956992718, 0.282849981634144, 0.7363872911265287, 0.6015518382081952], [0.8752776813276878, 0.2996279485812928, 0.13888614408354494, 0.08344348318416006]]], [[[0.34750149160171884, 0.7564914031965304, 0.027245770926107582, 0.5757061321651941], [0.4958948557109324, 0.7598995318359827, 0.42848139698339205, 0.016097918927411303], [0.9262882998672358, 0.7883925724033938, 0.6080922556620691, 0.6129944159801674]], [[0.9537961812064384, 0.134407738154536, 0.5126105369886191, 0.7111473155163776], [0.9153864068679111, 0.9074431910467052, 0.5483818056916192, 0.9309973883497766], [0.492291954922345, 0.35451124254040933, 0.3561789012121256, 0.4475198980036986]]]] ,numpy.float_)
86711          arg = Data(val,w_arg)
86712          res=interpolate(arg,where=w_ref)
86713          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86714          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86715          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
86716          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86717       def test_interpolate_onFunctionOnContactOne_fromConstant_onFunctionOnContactOne_rank0(self):
86718          """
86719          test interploation of constant rank 0 Data on FunctionOnContactOne
86720          """
86721          w_ref = FunctionOnContactOne(self.domain)
86722          w_arg = FunctionOnContactOne(self.domain)
86723          val = 3.346270e-01
86724          arg = Data(val,(),w_arg)
86725          res=interpolate(arg,where=w_ref)
86726          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86727          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86728          self.assertEqual(res.getShape(),(),"wrong shape of result.")
86729          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86730       def test_interpolate_onFunctionOnContactOne_fromConstant_onFunctionOnContactOne_rank1(self):
86731          """
86732          test interploation of constant rank 1 Data on FunctionOnContactOne
86733          """
86734          w_ref = FunctionOnContactOne(self.domain)
86735          w_arg = FunctionOnContactOne(self.domain)
86736          val = numpy.array([0.19203830022700397, 0.29393614853109507, 0.2927788998014659] ,numpy.float_)
86737          arg = Data(val,w_arg)
86738          res=interpolate(arg,where=w_ref)
86739          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86740          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86741          self.assertEqual(res.getShape(),(3,),"wrong shape of result.")
86742          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86743       def test_interpolate_onFunctionOnContactOne_fromConstant_onFunctionOnContactOne_rank2(self):
86744          """
86745          test interploation of constant rank 2 Data on FunctionOnContactOne
86746          """
86747          w_ref = FunctionOnContactOne(self.domain)
86748          w_arg = FunctionOnContactOne(self.domain)
86749          val = numpy.array([[0.17099980479408938, 0.16660487899571363], [0.2818948355524076, 0.9580210257403371], [0.17920860817050355, 0.2286630073717001], [0.9643645186245067, 0.8783395586003125]] ,numpy.float_)
86750          arg = Data(val,w_arg)
86751          res=interpolate(arg,where=w_ref)
86752          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86753          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86754          self.assertEqual(res.getShape(),(4, 2),"wrong shape of result.")
86755          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86756       def test_interpolate_onFunctionOnContactOne_fromConstant_onFunctionOnContactOne_rank3(self):
86757          """
86758          test interploation of constant rank 3 Data on FunctionOnContactOne
86759          """
86760          w_ref = FunctionOnContactOne(self.domain)
86761          w_arg = FunctionOnContactOne(self.domain)
86762          val = numpy.array([[[0.9393739922305128, 0.19033728614543044, 0.9770734231776671, 0.610912509126845], [0.6461057892571009, 0.14149710667856086, 0.1682075722230867, 0.9403474792723889]], [[0.8705275436933966, 0.5929405985046501, 0.6542425702772899, 0.878195309490558], [0.2812100926557496, 0.3801011519043189, 0.8529775975930917, 0.7474370026506547]]] ,numpy.float_)
86763          arg = Data(val,w_arg)
86764          res=interpolate(arg,where=w_ref)
86765          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86766          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86767          self.assertEqual(res.getShape(),(2, 2, 4),"wrong shape of result.")
86768          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86769       def test_interpolate_onFunctionOnContactOne_fromConstant_onFunctionOnContactOne_rank4(self):
86770          """
86771          test interploation of constant rank 4 Data on FunctionOnContactOne
86772          """
86773          w_ref = FunctionOnContactOne(self.domain)
86774          w_arg = FunctionOnContactOne(self.domain)
86775          val = numpy.array([[[[0.4230767108903867, 0.4194336862093251, 0.688756986286944, 0.9701998352992696], [0.3599725018981642, 0.4395651214979335, 0.39130830157406016, 0.35147621827791853], [0.06676920163915534, 0.22791986401980824, 0.475673299314337, 0.4026017674132487]], [[0.056366134507255916, 0.5741273447458412, 0.9519753634152845, 0.12822909211098554], [0.250119203532574, 0.6873115416399119, 0.5464406708874457, 0.7048880010667673], [0.635829361569282, 0.9342534453355489, 0.4911655802655164, 0.11099925917174758]]], [[[0.3131259925504235, 0.33032635347931416, 0.32002829136391986, 0.7341514812029089], [0.6248535441990961, 0.6864103652729907, 0.12363851297631567, 0.5799878793698392], [0.4708522022126608, 0.05850695501535841, 0.9175964491583588, 0.4316970415686543]], [[0.610380902656425, 0.7211048369384372, 0.7224220277694913, 0.9191863141386084], [0.4186251049927596, 0.7684041665858556, 0.14007754319815924, 0.8225602727877354], [0.5176881718188399, 0.9338567942806608, 0.4955060506872614, 0.504093908616572]]], [[[0.5617998823403688, 0.7395782993178911, 0.2832526237426829, 0.9167996032937219], [0.6024532952820588, 0.35446724141697894, 0.17631123315292152, 0.9664887509724667], [0.9637263605470135, 0.8739945809801134, 0.38677356757481307, 0.0813036805382904]], [[0.43864783261193485, 0.7036563752902615, 0.04635412572939557, 0.2755758826348347], [0.27150481049277986, 0.28020769195516304, 0.9719022050658143, 0.21077693846298318], [0.40391255123233794, 0.38188301804600777, 0.23516998176641224, 0.23820706739800213]]]] ,numpy.float_)
86776          arg = Data(val,w_arg)
86777          res=interpolate(arg,where=w_ref)
86778          self.assertTrue(isinstance(res,Data),"wrong type of result.")
86779          self.assertEqual(res.getFunctionSpace(),w_ref,"wrong functionspace of result.")
86780          self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
86781          self.assertTrue(Lsup(res-val)<=self.RES_TOL*Lsup(val),"wrong result")
86782    

Legend:
Removed from v.3797  
changed lines
  Added in v.3798

  ViewVC Help
Powered by ViewVC 1.1.26